text
stringlengths 4
5.48M
| meta
stringlengths 14
6.54k
|
|---|---|
title: NRO Symposium hoger onderwijs
author: Klinkenberg
date: '2021-01-15'
slug: nro-symposium-hoger-onderwijs
categories: []
tags: []
subtitle: 'Nieuwe richtingen na de pandemie?'
summary: ''
authors: []
lastmod: '2021-04-30T10:39:02+02:00'
featured: no
image:
caption: 'NRO Symposium'
focal_point: ''
preview_only: no
projects: []
---
Bijdrage aan het NRO Symposium 2021.
> Het online onderwijs brengt vraagstukken met zich mee over het op afstand of online toetsen en beoordelen van studenten. Hoe kunnen we dat nu en in de toekomst het beste vormgeven? Hoe kunnen we toetsen meer gaan gebruiken om studenten te ondersteunen bij het leren?
Bron: [Toetsen op afstand en monitoren van de studievoortgang](https://www.onderwijskennis.nl/nro-symposium-hoger-onderwijs-nieuwe-richtingen-na-de-pandemie/toetsen-op-afstand-en-monitoren-van-de-studievoortgang)
<iframe width="100%" height="315" src="https://www.youtube.com/embed/g6MiiQzOWfI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
Het [verslag van de sessie is hier te lezen](https://www.onderwijskennis.nl/nro-symposium-hoger-onderwijs-nieuwe-richtingen-na-de-pandemie/toetsen-op-afstand-en-monitoren-van-de-studievoortgang/verslag). Mijn [essay over Plaats- en tijdonafhankelijk toetsen is hier](https://www.onderwijskennis.nl/sites/onderwijskennis/files/media-files/Thema%205%20-%20Sharon%20Klinkenberg.pdf) te vinden. De overige essays van [Desirée Joosten-ten Brinke](https://www.linkedin.com/in/desirée-joosten-ten-brinke-15a9905/) en [Kim Schildkamp](https://www.linkedin.com/in/kim-schildkamp/) zijn [hier](https://www.onderwijskennis.nl/nro-symposium-hoger-onderwijs-nieuwe-richtingen-na-de-pandemie/toetsen-op-afstand-en-monitoren-van-de-studievoortgang) beschikbaar.
| {'content_hash': 'a26bb1c0e9ffa1c72b2f00c284aadbc4', 'timestamp': '', 'source': 'github', 'line_count': 28, 'max_line_length': 746, 'avg_line_length': 66.64285714285714, 'alnum_prop': 0.7888531618435155, 'repo_name': 'ShKlinkenberg/site', 'id': 'f6fcd790b26c4b555a4186b0bf1f516188d3218d', 'size': '1872', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'content/event/2021-01-15-nro-symposium-hoger-onderwijs/index.nl.md', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '19391'}, {'name': 'HTML', 'bytes': '46197'}, {'name': 'JavaScript', 'bytes': '6851'}]} |
<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- $Id$ -->
<html>
<head>
<title>Tapestry: Web Application Framework</title>
</head>
<body>
<p>Provides implementations of callbacks, objects that encapsulate a server request that is deferred,
typically to allow a user to login or otherwise authenticate before proceeding with
some other activity.
<p>In practice, an implementation of {@link org.apache.tapestry.IPage#validate(IRequestCycle)} or
{@link org.apache.tapestry.IActionListener} will create a callback, and assign it as a
persistent page property of an application-specific login page. After the login completes, it
can use the callback to return the user to the functionality that was deferred.
<p>Another example use would be to collect billing and shipping information as part of
an e-commerce site's checkout wizard.
@author Howard Lewis Ship <a href="mailto:[email protected]">[email protected]</a>
</body>
</html>
| {'content_hash': 'd5fa677bdfc8b7c7709a0b760fb17225', 'timestamp': '', 'source': 'github', 'line_count': 24, 'max_line_length': 101, 'avg_line_length': 39.75, 'alnum_prop': 0.7725366876310272, 'repo_name': 'apache/tapestry3', 'id': '662339615e5f58c53e47565cdbb8679887a2c62a', 'size': '954', 'binary': False, 'copies': '2', 'ref': 'refs/heads/trunk', 'path': 'tapestry-framework/src/org/apache/tapestry/callback/package.html', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'CSS', 'bytes': '11210'}, {'name': 'HTML', 'bytes': '199901'}, {'name': 'Java', 'bytes': '3116661'}, {'name': 'JavaScript', 'bytes': '52812'}, {'name': 'Perl', 'bytes': '2992'}]} |
package core
import (
"math"
"github.com/pingcap/errors"
"github.com/pingcap/parser/ast"
"github.com/pingcap/parser/model"
"github.com/pingcap/parser/mysql"
"github.com/pingcap/parser/terror"
"github.com/pingcap/tidb/expression"
"github.com/pingcap/tidb/expression/aggregation"
"github.com/pingcap/tidb/planner/property"
"github.com/pingcap/tidb/types"
"github.com/pingcap/tidb/util/ranger"
)
func (p *LogicalUnionScan) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
us := PhysicalUnionScan{Conditions: p.conditions}.Init(p.ctx, p.stats, prop)
return []PhysicalPlan{us}
}
func getMaxSortPrefix(sortCols, allCols []*expression.Column) []int {
tmpSchema := expression.NewSchema(allCols...)
sortColOffsets := make([]int, 0, len(sortCols))
for _, sortCol := range sortCols {
offset := tmpSchema.ColumnIndex(sortCol)
if offset == -1 {
return sortColOffsets
}
sortColOffsets = append(sortColOffsets, offset)
}
return sortColOffsets
}
func findMaxPrefixLen(candidates [][]*expression.Column, keys []*expression.Column) int {
maxLen := 0
for _, candidateKeys := range candidates {
matchedLen := 0
for i := range keys {
if i < len(candidateKeys) && keys[i].Equal(nil, candidateKeys[i]) {
matchedLen++
} else {
break
}
}
if matchedLen > maxLen {
maxLen = matchedLen
}
}
return maxLen
}
func (p *LogicalJoin) moveEqualToOtherConditions(offsets []int) []expression.Expression {
otherConds := make([]expression.Expression, len(p.OtherConditions))
copy(otherConds, p.OtherConditions)
for i, eqCond := range p.EqualConditions {
match := false
for _, offset := range offsets {
if i == offset {
match = true
break
}
}
if !match {
otherConds = append(otherConds, eqCond)
}
}
return otherConds
}
// Only if the input required prop is the prefix fo join keys, we can pass through this property.
func (p *PhysicalMergeJoin) tryToGetChildReqProp(prop *property.PhysicalProperty) ([]*property.PhysicalProperty, bool) {
lProp := &property.PhysicalProperty{TaskTp: property.RootTaskType, Cols: p.LeftKeys, ExpectedCnt: math.MaxFloat64}
rProp := &property.PhysicalProperty{TaskTp: property.RootTaskType, Cols: p.RightKeys, ExpectedCnt: math.MaxFloat64}
if !prop.IsEmpty() {
// sort merge join fits the cases of massive ordered data, so desc scan is always expensive.
if prop.Desc {
return nil, false
}
if !prop.IsPrefix(lProp) && !prop.IsPrefix(rProp) {
return nil, false
}
if prop.IsPrefix(rProp) && p.JoinType == LeftOuterJoin {
return nil, false
}
if prop.IsPrefix(lProp) && p.JoinType == RightOuterJoin {
return nil, false
}
}
return []*property.PhysicalProperty{lProp, rProp}, true
}
func (p *LogicalJoin) getMergeJoin(prop *property.PhysicalProperty) []PhysicalPlan {
joins := make([]PhysicalPlan, 0, len(p.leftProperties))
// The leftProperties caches all the possible properties that are provided by its children.
for _, lhsChildProperty := range p.leftProperties {
offsets := getMaxSortPrefix(lhsChildProperty, p.LeftJoinKeys)
if len(offsets) == 0 {
continue
}
leftKeys := lhsChildProperty[:len(offsets)]
rightKeys := expression.NewSchema(p.RightJoinKeys...).ColumnsByIndices(offsets)
prefixLen := findMaxPrefixLen(p.rightProperties, rightKeys)
if prefixLen == 0 {
continue
}
leftKeys = leftKeys[:prefixLen]
rightKeys = rightKeys[:prefixLen]
offsets = offsets[:prefixLen]
mergeJoin := PhysicalMergeJoin{
JoinType: p.JoinType,
LeftConditions: p.LeftConditions,
RightConditions: p.RightConditions,
DefaultValues: p.DefaultValues,
LeftKeys: leftKeys,
RightKeys: rightKeys,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt))
mergeJoin.SetSchema(p.schema)
mergeJoin.OtherConditions = p.moveEqualToOtherConditions(offsets)
if reqProps, ok := mergeJoin.tryToGetChildReqProp(prop); ok {
mergeJoin.childrenReqProps = reqProps
joins = append(joins, mergeJoin)
}
}
// If TiDB_SMJ hint is existed && no join keys in children property,
// it should to enforce merge join.
if len(joins) == 0 && (p.preferJoinType&preferMergeJoin) > 0 {
return p.getEnforcedMergeJoin(prop)
}
return joins
}
// Change JoinKeys order, by offsets array
// offsets array is generate by prop check
func getNewJoinKeysByOffsets(oldJoinKeys []*expression.Column, offsets []int) []*expression.Column {
newKeys := make([]*expression.Column, 0, len(oldJoinKeys))
for _, offset := range offsets {
newKeys = append(newKeys, oldJoinKeys[offset])
}
for pos, key := range oldJoinKeys {
isExist := false
for _, p := range offsets {
if p == pos {
isExist = true
break
}
}
if !isExist {
newKeys = append(newKeys, key)
}
}
return newKeys
}
// Change EqualConditions order, by offsets array
// offsets array is generate by prop check
func getNewEqualConditionsByOffsets(oldEqualCond []*expression.ScalarFunction, offsets []int) []*expression.ScalarFunction {
newEqualCond := make([]*expression.ScalarFunction, 0, len(oldEqualCond))
for _, offset := range offsets {
newEqualCond = append(newEqualCond, oldEqualCond[offset])
}
for pos, condition := range oldEqualCond {
isExist := false
for _, p := range offsets {
if p == pos {
isExist = true
break
}
}
if !isExist {
newEqualCond = append(newEqualCond, condition)
}
}
return newEqualCond
}
func (p *LogicalJoin) getEnforcedMergeJoin(prop *property.PhysicalProperty) []PhysicalPlan {
// Check whether SMJ can satisfy the required property
offsets := make([]int, 0, len(p.LeftJoinKeys))
for _, col := range prop.Cols {
isExist := false
for joinKeyPos := 0; joinKeyPos < len(p.LeftJoinKeys); joinKeyPos++ {
var key *expression.Column
if col.Equal(p.ctx, p.LeftJoinKeys[joinKeyPos]) {
key = p.LeftJoinKeys[joinKeyPos]
}
if col.Equal(p.ctx, p.RightJoinKeys[joinKeyPos]) {
key = p.RightJoinKeys[joinKeyPos]
}
if key == nil {
continue
}
for i := 0; i < len(offsets); i++ {
if offsets[i] == joinKeyPos {
isExist = true
break
}
}
if !isExist {
offsets = append(offsets, joinKeyPos)
}
isExist = true
break
}
if !isExist {
return nil
}
}
// Generate the enforced sort merge join
leftKeys := getNewJoinKeysByOffsets(p.LeftJoinKeys, offsets)
rightKeys := getNewJoinKeysByOffsets(p.RightJoinKeys, offsets)
lProp := &property.PhysicalProperty{TaskTp: property.RootTaskType, Cols: leftKeys, ExpectedCnt: math.MaxFloat64, Enforced: true, Desc: prop.Desc}
rProp := &property.PhysicalProperty{TaskTp: property.RootTaskType, Cols: rightKeys, ExpectedCnt: math.MaxFloat64, Enforced: true, Desc: prop.Desc}
enforcedPhysicalMergeJoin := PhysicalMergeJoin{
JoinType: p.JoinType,
LeftConditions: p.LeftConditions,
RightConditions: p.RightConditions,
DefaultValues: p.DefaultValues,
LeftKeys: leftKeys,
RightKeys: rightKeys,
OtherConditions: p.OtherConditions,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt))
enforcedPhysicalMergeJoin.SetSchema(p.schema)
enforcedPhysicalMergeJoin.childrenReqProps = []*property.PhysicalProperty{lProp, rProp}
return []PhysicalPlan{enforcedPhysicalMergeJoin}
}
func (p *LogicalJoin) getHashJoins(prop *property.PhysicalProperty) []PhysicalPlan {
if !prop.IsEmpty() { // hash join doesn't promise any orders
return nil
}
joins := make([]PhysicalPlan, 0, 2)
switch p.JoinType {
case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin, LeftOuterJoin:
joins = append(joins, p.getHashJoin(prop, 1))
case RightOuterJoin:
joins = append(joins, p.getHashJoin(prop, 0))
case InnerJoin:
joins = append(joins, p.getHashJoin(prop, 1))
joins = append(joins, p.getHashJoin(prop, 0))
}
return joins
}
func (p *LogicalJoin) getHashJoin(prop *property.PhysicalProperty, innerIdx int) *PhysicalHashJoin {
chReqProps := make([]*property.PhysicalProperty, 2)
chReqProps[innerIdx] = &property.PhysicalProperty{ExpectedCnt: math.MaxFloat64}
chReqProps[1-innerIdx] = &property.PhysicalProperty{ExpectedCnt: prop.ExpectedCnt}
hashJoin := PhysicalHashJoin{
EqualConditions: p.EqualConditions,
LeftConditions: p.LeftConditions,
RightConditions: p.RightConditions,
OtherConditions: p.OtherConditions,
JoinType: p.JoinType,
Concurrency: uint(p.ctx.GetSessionVars().HashJoinConcurrency),
DefaultValues: p.DefaultValues,
InnerChildIdx: innerIdx,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), chReqProps...)
hashJoin.SetSchema(p.schema)
return hashJoin
}
// joinKeysMatchIndex checks whether the join key is in the index.
// It returns a slice a[] what a[i] means keys[i] is related with indexCols[a[i]], -1 for no matching column.
// It will return nil if there's no column that matches index.
func joinKeysMatchIndex(keys, indexCols []*expression.Column, colLengths []int) []int {
keyOff2IdxOff := make([]int, len(keys))
for i := range keyOff2IdxOff {
keyOff2IdxOff[i] = -1
}
// There should be at least one column in join keys which can match the index's column.
matched := false
tmpSchema := expression.NewSchema(keys...)
for i, idxCol := range indexCols {
if colLengths[i] != types.UnspecifiedLength {
continue
}
keyOff := tmpSchema.ColumnIndex(idxCol)
if keyOff == -1 {
continue
}
matched = true
keyOff2IdxOff[keyOff] = i
}
if !matched {
return nil
}
return keyOff2IdxOff
}
// When inner plan is TableReader, the parameter `ranges` will be nil. Because pk only have one column. So all of its range
// is generated during execution time.
func (p *LogicalJoin) constructIndexJoin(prop *property.PhysicalProperty, innerJoinKeys, outerJoinKeys []*expression.Column, outerIdx int,
innerPlan PhysicalPlan, ranges []*ranger.Range, keyOff2IdxOff []int) []PhysicalPlan {
joinType := p.JoinType
outerSchema := p.children[outerIdx].Schema()
// If the order by columns are not all from outer child, index join cannot promise the order.
if !prop.AllColsFromSchema(outerSchema) {
return nil
}
chReqProps := make([]*property.PhysicalProperty, 2)
chReqProps[outerIdx] = &property.PhysicalProperty{TaskTp: property.RootTaskType, ExpectedCnt: prop.ExpectedCnt, Cols: prop.Cols, Desc: prop.Desc}
newInnerKeys := make([]*expression.Column, 0, len(innerJoinKeys))
newOuterKeys := make([]*expression.Column, 0, len(outerJoinKeys))
newKeyOff := make([]int, 0, len(keyOff2IdxOff))
newOtherConds := make([]expression.Expression, len(p.OtherConditions), len(p.OtherConditions)+len(p.EqualConditions))
copy(newOtherConds, p.OtherConditions)
for keyOff, idxOff := range keyOff2IdxOff {
if keyOff2IdxOff[keyOff] < 0 {
newOtherConds = append(newOtherConds, p.EqualConditions[keyOff])
continue
}
newInnerKeys = append(newInnerKeys, innerJoinKeys[keyOff])
newOuterKeys = append(newOuterKeys, outerJoinKeys[keyOff])
newKeyOff = append(newKeyOff, idxOff)
}
join := PhysicalIndexJoin{
OuterIndex: outerIdx,
LeftConditions: p.LeftConditions,
RightConditions: p.RightConditions,
OtherConditions: newOtherConds,
JoinType: joinType,
OuterJoinKeys: newOuterKeys,
InnerJoinKeys: newInnerKeys,
DefaultValues: p.DefaultValues,
innerPlan: innerPlan,
KeyOff2IdxOff: newKeyOff,
Ranges: ranges,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), chReqProps...)
join.SetSchema(p.schema)
return []PhysicalPlan{join}
}
// getIndexJoinByOuterIdx will generate index join by outerIndex. OuterIdx points out the outer child.
// First of all, we'll check whether the inner child is DataSource.
// Then, we will extract the join keys of p's equal conditions. Then check whether all of them are just the primary key
// or match some part of on index. If so we will choose the best one and construct a index join.
func (p *LogicalJoin) getIndexJoinByOuterIdx(prop *property.PhysicalProperty, outerIdx int) []PhysicalPlan {
innerChild := p.children[1-outerIdx]
var (
innerJoinKeys []*expression.Column
outerJoinKeys []*expression.Column
)
if outerIdx == 0 {
outerJoinKeys = p.LeftJoinKeys
innerJoinKeys = p.RightJoinKeys
} else {
innerJoinKeys = p.LeftJoinKeys
outerJoinKeys = p.RightJoinKeys
}
ds, isDataSource := innerChild.(*DataSource)
us, isUnionScan := innerChild.(*LogicalUnionScan)
if !isDataSource && !isUnionScan {
return nil
}
if isUnionScan {
ds = us.Children()[0].(*DataSource)
}
var tblPath *accessPath
for _, path := range ds.possibleAccessPaths {
if path.isTablePath {
tblPath = path
break
}
}
if pkCol := ds.getPKIsHandleCol(); pkCol != nil && tblPath != nil {
keyOff2IdxOff := make([]int, len(innerJoinKeys))
pkMatched := false
for i, key := range innerJoinKeys {
if !key.Equal(nil, pkCol) {
keyOff2IdxOff[i] = -1
continue
}
pkMatched = true
keyOff2IdxOff[i] = 0
}
if pkMatched {
innerPlan := p.constructInnerTableScan(ds, pkCol, outerJoinKeys, us)
// Since the primary key means one value corresponding to exact one row, this will always be a no worse one
// comparing to other index.
return p.constructIndexJoin(prop, innerJoinKeys, outerJoinKeys, outerIdx, innerPlan, nil, keyOff2IdxOff)
}
}
var (
bestIndexInfo *model.IndexInfo
rangesOfBest []*ranger.Range
maxUsedCols int
remainedOfBest []expression.Expression
keyOff2IdxOff []int
)
for _, path := range ds.possibleAccessPaths {
if path.isTablePath {
continue
}
indexInfo := path.index
ranges, remained, tmpKeyOff2IdxOff := p.buildRangeForIndexJoin(indexInfo, ds, innerJoinKeys)
// We choose the index by the number of used columns of the range, the much the better.
// Notice that there may be the cases like `t1.a=t2.a and b > 2 and b < 1`. So ranges can be nil though the conditions are valid.
// But obviously when the range is nil, we don't need index join.
if len(ranges) > 0 && len(ranges[0].LowVal) > maxUsedCols {
bestIndexInfo = indexInfo
maxUsedCols = len(ranges[0].LowVal)
rangesOfBest = ranges
remainedOfBest = remained
keyOff2IdxOff = tmpKeyOff2IdxOff
}
}
if bestIndexInfo != nil {
innerPlan := p.constructInnerIndexScan(ds, bestIndexInfo, remainedOfBest, outerJoinKeys, us)
return p.constructIndexJoin(prop, innerJoinKeys, outerJoinKeys, outerIdx, innerPlan, rangesOfBest, keyOff2IdxOff)
}
return nil
}
// constructInnerTableScan is specially used to construct the inner plan for PhysicalIndexJoin.
func (p *LogicalJoin) constructInnerTableScan(ds *DataSource, pk *expression.Column, outerJoinKeys []*expression.Column, us *LogicalUnionScan) PhysicalPlan {
ranges := ranger.FullIntRange(mysql.HasUnsignedFlag(pk.RetType.Flag))
ts := PhysicalTableScan{
Table: ds.tableInfo,
Columns: ds.Columns,
TableAsName: ds.TableAsName,
DBName: ds.DBName,
filterCondition: ds.pushedDownConds,
Ranges: ranges,
rangeDecidedBy: outerJoinKeys,
}.Init(ds.ctx)
ts.SetSchema(ds.schema)
var rowCount float64
pkHist, ok := ds.statisticTable.Columns[pk.ID]
if ok && !ds.statisticTable.Pseudo {
rowCount = pkHist.AvgCountPerValue(ds.statisticTable.Count)
} else {
rowCount = ds.statisticTable.PseudoAvgCountPerValue()
}
ts.stats = property.NewSimpleStats(rowCount)
ts.stats.UsePseudoStats = ds.statisticTable.Pseudo
copTask := &copTask{
tablePlan: ts,
indexPlanFinished: true,
}
ts.addPushedDownSelection(copTask, ds.stats)
t := finishCopTask(ds.ctx, copTask)
reader := t.plan()
return p.constructInnerUnionScan(us, reader)
}
func (p *LogicalJoin) constructInnerUnionScan(us *LogicalUnionScan, reader PhysicalPlan) PhysicalPlan {
if us == nil {
return reader
}
// Use `reader.stats` instead of `us.stats` because it should be more accurate. No need to specify
// childrenReqProps now since we have got reader already.
physicalUnionScan := PhysicalUnionScan{Conditions: us.conditions}.Init(us.ctx, reader.statsInfo(), nil)
physicalUnionScan.SetChildren(reader)
return physicalUnionScan
}
// constructInnerIndexScan is specially used to construct the inner plan for PhysicalIndexJoin.
func (p *LogicalJoin) constructInnerIndexScan(ds *DataSource, idx *model.IndexInfo, remainedConds []expression.Expression, outerJoinKeys []*expression.Column, us *LogicalUnionScan) PhysicalPlan {
is := PhysicalIndexScan{
Table: ds.tableInfo,
TableAsName: ds.TableAsName,
DBName: ds.DBName,
Columns: ds.Columns,
Index: idx,
dataSourceSchema: ds.schema,
KeepOrder: false,
Ranges: ranger.FullRange(),
rangeDecidedBy: outerJoinKeys,
}.Init(ds.ctx)
is.filterCondition = remainedConds
var rowCount float64
idxHist, ok := ds.statisticTable.Indices[idx.ID]
if ok && !ds.statisticTable.Pseudo {
rowCount = idxHist.AvgCountPerValue(ds.statisticTable.Count)
} else {
rowCount = ds.statisticTable.PseudoAvgCountPerValue()
}
is.stats = property.NewSimpleStats(rowCount)
is.stats.UsePseudoStats = ds.statisticTable.Pseudo
cop := &copTask{
indexPlan: is,
}
if !isCoveringIndex(ds.schema.Columns, is.Index.Columns, is.Table.PKIsHandle) {
// On this way, it's double read case.
ts := PhysicalTableScan{Columns: ds.Columns, Table: is.Table}.Init(ds.ctx)
ts.SetSchema(is.dataSourceSchema)
cop.tablePlan = ts
}
is.initSchema(ds.id, idx, cop.tablePlan != nil)
indexConds, tblConds := splitIndexFilterConditions(remainedConds, idx.Columns, ds.tableInfo)
path := &accessPath{indexFilters: indexConds, tableFilters: tblConds, countAfterIndex: math.MaxFloat64}
is.addPushedDownSelection(cop, ds, math.MaxFloat64, path)
t := finishCopTask(ds.ctx, cop)
reader := t.plan()
return p.constructInnerUnionScan(us, reader)
}
// buildRangeForIndexJoin checks whether this index can be used for building index join and return the range if this index is ok.
// If this index is invalid, just return nil range.
func (p *LogicalJoin) buildRangeForIndexJoin(indexInfo *model.IndexInfo, innerPlan *DataSource, innerJoinKeys []*expression.Column) (
[]*ranger.Range, []expression.Expression, []int) {
idxCols, colLengths := expression.IndexInfo2Cols(innerPlan.Schema().Columns, indexInfo)
if len(idxCols) == 0 {
return nil, nil, nil
}
// Extract the filter to calculate access and the filters that must be remained ones.
access, eqConds, remained, keyOff2IdxOff := p.buildFakeEqCondsForIndexJoin(innerJoinKeys, idxCols, colLengths, innerPlan.pushedDownConds)
if len(keyOff2IdxOff) == 0 {
return nil, nil, nil
}
// In `buildFakeEqCondsForIndexJoin`, we construct the equal conditions for join keys and remove filters that contain the join keys' column.
// When t1.a = t2.a and t1.a > 1, we can also guarantee that t1.a > 1 won't be chosen as the access condition.
// So the equal conditions we built can be successfully used to build a range if they can be used. They won't be affected by the existing filters.
ranges, accesses, moreRemained, _, err := ranger.DetachCondAndBuildRangeForIndex(p.ctx, access, idxCols, colLengths)
if err != nil {
terror.Log(errors.Trace(err))
return nil, nil, nil
}
// We should guarantee that all the join's equal condition is used.
for _, eqCond := range eqConds {
if !expression.Contains(accesses, eqCond) {
return nil, nil, nil
}
}
return ranges, append(remained, moreRemained...), keyOff2IdxOff
}
func (p *LogicalJoin) buildFakeEqCondsForIndexJoin(keys, idxCols []*expression.Column, colLengths []int,
innerFilters []expression.Expression) (accesses, eqConds, remained []expression.Expression, keyOff2IdxOff []int) {
// Check whether all join keys match one column from index.
keyOff2IdxOff = joinKeysMatchIndex(keys, idxCols, colLengths)
if keyOff2IdxOff == nil {
return nil, nil, nil, nil
}
usableKeys := make([]*expression.Column, 0, len(keys))
conds := make([]expression.Expression, 0, len(keys)+len(innerFilters))
eqConds = make([]expression.Expression, 0, len(keys))
// Construct a fake equal expression for every join key for calculating the range.
for i, key := range keys {
if keyOff2IdxOff[i] < 0 {
continue
}
usableKeys = append(usableKeys, key)
// Int datum 1 can convert to all column's type(numeric type, string type, json, time type, enum, set) safely.
fakeConstant := &expression.Constant{Value: types.NewIntDatum(1), RetType: key.GetType()}
eqFunc := expression.NewFunctionInternal(p.ctx, ast.EQ, types.NewFieldType(mysql.TypeTiny), key, fakeConstant)
conds = append(conds, eqFunc)
eqConds = append(eqConds, eqFunc)
}
// Look into every `innerFilter`, if it contains join keys' column, put this filter into `remained` part directly.
remained = make([]expression.Expression, 0, len(innerFilters))
for _, filter := range innerFilters {
affectedCols := expression.ExtractColumns(filter)
if expression.ColumnSliceIsIntersect(affectedCols, usableKeys) {
remained = append(remained, filter)
continue
}
conds = append(conds, filter)
}
return conds, eqConds, remained, keyOff2IdxOff
}
// tryToGetIndexJoin will get index join by hints. If we can generate a valid index join by hint, the second return value
// will be true, which means we force to choose this index join. Otherwise we will select a join algorithm with min-cost.
func (p *LogicalJoin) tryToGetIndexJoin(prop *property.PhysicalProperty) ([]PhysicalPlan, bool) {
if len(p.EqualConditions) == 0 {
return nil, false
}
plans := make([]PhysicalPlan, 0, 2)
rightOuter := (p.preferJoinType & preferLeftAsIndexInner) > 0
leftOuter := (p.preferJoinType & preferRightAsIndexInner) > 0
switch p.JoinType {
case SemiJoin, AntiSemiJoin, LeftOuterSemiJoin, AntiLeftOuterSemiJoin, LeftOuterJoin:
join := p.getIndexJoinByOuterIdx(prop, 0)
if join != nil {
// If the plan is not nil and matches the hint, return it directly.
if leftOuter {
return join, true
}
plans = append(plans, join...)
}
case RightOuterJoin:
join := p.getIndexJoinByOuterIdx(prop, 1)
if join != nil {
// If the plan is not nil and matches the hint, return it directly.
if rightOuter {
return join, true
}
plans = append(plans, join...)
}
case InnerJoin:
lhsCardinality := p.Children()[0].statsInfo().Count()
rhsCardinality := p.Children()[1].statsInfo().Count()
leftJoins := p.getIndexJoinByOuterIdx(prop, 0)
if leftOuter && leftJoins != nil {
return leftJoins, true
}
rightJoins := p.getIndexJoinByOuterIdx(prop, 1)
if rightOuter && rightJoins != nil {
return rightJoins, true
}
if leftJoins != nil && lhsCardinality < rhsCardinality {
return leftJoins, leftOuter
}
if rightJoins != nil && rhsCardinality < lhsCardinality {
return rightJoins, rightOuter
}
plans = append(plans, leftJoins...)
plans = append(plans, rightJoins...)
}
return plans, false
}
// LogicalJoin can generates hash join, index join and sort merge join.
// Firstly we check the hint, if hint is figured by user, we force to choose the corresponding physical plan.
// If the hint is not matched, it will get other candidates.
// If the hint is not figured, we will pick all candidates.
func (p *LogicalJoin) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
mergeJoins := p.getMergeJoin(prop)
if (p.preferJoinType & preferMergeJoin) > 0 {
return mergeJoins
}
joins := make([]PhysicalPlan, 0, 5)
joins = append(joins, mergeJoins...)
indexJoins, forced := p.tryToGetIndexJoin(prop)
if forced {
return indexJoins
}
joins = append(joins, indexJoins...)
hashJoins := p.getHashJoins(prop)
if (p.preferJoinType & preferHashJoin) > 0 {
return hashJoins
}
joins = append(joins, hashJoins...)
return joins
}
// tryToGetChildProp will check if this sort property can be pushed or not.
// When a sort column will be replaced by scalar function, we refuse it.
// When a sort column will be replaced by a constant, we just remove it.
func (p *LogicalProjection) tryToGetChildProp(prop *property.PhysicalProperty) (*property.PhysicalProperty, bool) {
newProp := &property.PhysicalProperty{TaskTp: property.RootTaskType, ExpectedCnt: prop.ExpectedCnt}
newCols := make([]*expression.Column, 0, len(prop.Cols))
for _, col := range prop.Cols {
idx := p.schema.ColumnIndex(col)
switch expr := p.Exprs[idx].(type) {
case *expression.Column:
newCols = append(newCols, expr)
case *expression.ScalarFunction:
return nil, false
}
}
newProp.Cols = newCols
newProp.Desc = prop.Desc
return newProp, true
}
func (p *LogicalProjection) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
newProp, ok := p.tryToGetChildProp(prop)
if !ok {
return nil
}
proj := PhysicalProjection{
Exprs: p.Exprs,
CalculateNoDelay: p.calculateNoDelay,
AvoidColumnEvaluator: p.avoidColumnEvaluator,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), newProp)
proj.SetSchema(p.schema)
return []PhysicalPlan{proj}
}
func (lt *LogicalTopN) getPhysTopN() []PhysicalPlan {
ret := make([]PhysicalPlan, 0, 3)
for _, tp := range wholeTaskTypes {
resultProp := &property.PhysicalProperty{TaskTp: tp, ExpectedCnt: math.MaxFloat64}
topN := PhysicalTopN{
ByItems: lt.ByItems,
Count: lt.Count,
Offset: lt.Offset,
}.Init(lt.ctx, lt.stats, resultProp)
ret = append(ret, topN)
}
return ret
}
func (lt *LogicalTopN) getPhysLimits() []PhysicalPlan {
prop, canPass := getPropByOrderByItems(lt.ByItems)
if !canPass {
return nil
}
ret := make([]PhysicalPlan, 0, 3)
for _, tp := range wholeTaskTypes {
resultProp := &property.PhysicalProperty{TaskTp: tp, ExpectedCnt: float64(lt.Count + lt.Offset), Cols: prop.Cols, Desc: prop.Desc}
limit := PhysicalLimit{
Count: lt.Count,
Offset: lt.Offset,
}.Init(lt.ctx, lt.stats, resultProp)
ret = append(ret, limit)
}
return ret
}
// Check if this prop's columns can match by items totally.
func matchItems(p *property.PhysicalProperty, items []*ByItems) bool {
if len(items) < len(p.Cols) {
return false
}
for i, col := range p.Cols {
sortItem := items[i]
if sortItem.Desc != p.Desc || !sortItem.Expr.Equal(nil, col) {
return false
}
}
return true
}
func (lt *LogicalTopN) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
if matchItems(prop, lt.ByItems) {
return append(lt.getPhysTopN(), lt.getPhysLimits()...)
}
return nil
}
func (la *LogicalApply) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
if !prop.AllColsFromSchema(la.children[0].Schema()) { // for convenient, we don't pass through any prop
return nil
}
apply := PhysicalApply{
PhysicalJoin: la.getHashJoin(prop, 1),
OuterSchema: la.corCols,
rightChOffset: la.children[0].Schema().Len(),
}.Init(la.ctx,
la.stats.ScaleByExpectCnt(prop.ExpectedCnt),
&property.PhysicalProperty{ExpectedCnt: math.MaxFloat64, Cols: prop.Cols, Desc: prop.Desc},
&property.PhysicalProperty{ExpectedCnt: math.MaxFloat64})
apply.SetSchema(la.schema)
return []PhysicalPlan{apply}
}
// exhaustPhysicalPlans is only for implementing interface. DataSource and Dual generate task in `findBestTask` directly.
func (p *baseLogicalPlan) exhaustPhysicalPlans(_ *property.PhysicalProperty) []PhysicalPlan {
panic("baseLogicalPlan.exhaustPhysicalPlans() should never be called.")
}
func (la *LogicalAggregation) getStreamAggs(prop *property.PhysicalProperty) []PhysicalPlan {
if len(la.possibleProperties) == 0 {
return nil
}
for _, aggFunc := range la.AggFuncs {
if aggFunc.Mode == aggregation.FinalMode {
return nil
}
}
// group by a + b is not interested in any order.
if len(la.groupByCols) != len(la.GroupByItems) {
return nil
}
streamAggs := make([]PhysicalPlan, 0, len(la.possibleProperties)*(len(wholeTaskTypes)-1))
childProp := &property.PhysicalProperty{
Desc: prop.Desc,
ExpectedCnt: math.Max(prop.ExpectedCnt*la.inputCount/la.stats.RowCount, prop.ExpectedCnt),
}
for _, possibleChildProperty := range la.possibleProperties {
sortColOffsets := getMaxSortPrefix(possibleChildProperty, la.groupByCols)
if len(sortColOffsets) != len(la.groupByCols) {
continue
}
childProp.Cols = possibleChildProperty[:len(sortColOffsets)]
if !prop.IsPrefix(childProp) {
continue
}
// The table read of "CopDoubleReadTaskType" can't promises the sort
// property that the stream aggregation required, no need to consider.
for _, taskTp := range []property.TaskType{property.CopSingleReadTaskType, property.RootTaskType} {
copiedChildProperty := new(property.PhysicalProperty)
*copiedChildProperty = *childProp // It's ok to not deep copy the "cols" field.
copiedChildProperty.TaskTp = taskTp
agg := basePhysicalAgg{
GroupByItems: la.GroupByItems,
AggFuncs: la.AggFuncs,
}.initForStream(la.ctx, la.stats.ScaleByExpectCnt(prop.ExpectedCnt), copiedChildProperty)
agg.SetSchema(la.schema.Clone())
streamAggs = append(streamAggs, agg)
}
}
return streamAggs
}
func (la *LogicalAggregation) getHashAggs(prop *property.PhysicalProperty) []PhysicalPlan {
if !prop.IsEmpty() {
return nil
}
hashAggs := make([]PhysicalPlan, 0, len(wholeTaskTypes))
for _, taskTp := range wholeTaskTypes {
agg := basePhysicalAgg{
GroupByItems: la.GroupByItems,
AggFuncs: la.AggFuncs,
}.initForHash(la.ctx, la.stats.ScaleByExpectCnt(prop.ExpectedCnt), &property.PhysicalProperty{ExpectedCnt: math.MaxFloat64, TaskTp: taskTp})
agg.SetSchema(la.schema.Clone())
hashAggs = append(hashAggs, agg)
}
return hashAggs
}
func (la *LogicalAggregation) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
aggs := make([]PhysicalPlan, 0, len(la.possibleProperties)+1)
aggs = append(aggs, la.getHashAggs(prop)...)
aggs = append(aggs, la.getStreamAggs(prop)...)
return aggs
}
func (p *LogicalSelection) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
sel := PhysicalSelection{
Conditions: p.Conditions,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), prop)
return []PhysicalPlan{sel}
}
func (p *LogicalLimit) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
if !prop.IsEmpty() {
return nil
}
ret := make([]PhysicalPlan, 0, len(wholeTaskTypes))
for _, tp := range wholeTaskTypes {
resultProp := &property.PhysicalProperty{TaskTp: tp, ExpectedCnt: float64(p.Count + p.Offset)}
limit := PhysicalLimit{
Offset: p.Offset,
Count: p.Count,
}.Init(p.ctx, p.stats, resultProp)
ret = append(ret, limit)
}
return ret
}
func (p *LogicalLock) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
lock := PhysicalLock{
Lock: p.Lock,
}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), prop)
return []PhysicalPlan{lock}
}
func (p *LogicalUnionAll) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
// TODO: UnionAll can not pass any order, but we can change it to sort merge to keep order.
if !prop.IsEmpty() {
return nil
}
chReqProps := make([]*property.PhysicalProperty, 0, len(p.children))
for range p.children {
chReqProps = append(chReqProps, &property.PhysicalProperty{ExpectedCnt: prop.ExpectedCnt})
}
ua := PhysicalUnionAll{}.Init(p.ctx, p.stats.ScaleByExpectCnt(prop.ExpectedCnt), chReqProps...)
ua.SetSchema(p.Schema())
return []PhysicalPlan{ua}
}
func (ls *LogicalSort) getPhysicalSort(prop *property.PhysicalProperty) *PhysicalSort {
ps := PhysicalSort{ByItems: ls.ByItems}.Init(ls.ctx, ls.stats.ScaleByExpectCnt(prop.ExpectedCnt), &property.PhysicalProperty{ExpectedCnt: math.MaxFloat64})
return ps
}
func (ls *LogicalSort) getNominalSort(reqProp *property.PhysicalProperty) *NominalSort {
prop, canPass := getPropByOrderByItems(ls.ByItems)
if !canPass {
return nil
}
prop.ExpectedCnt = reqProp.ExpectedCnt
ps := NominalSort{}.Init(ls.ctx, prop)
return ps
}
func (ls *LogicalSort) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
if matchItems(prop, ls.ByItems) {
ret := make([]PhysicalPlan, 0, 2)
ret = append(ret, ls.getPhysicalSort(prop))
ns := ls.getNominalSort(prop)
if ns != nil {
ret = append(ret, ns)
}
return ret
}
return nil
}
func (p *LogicalMaxOneRow) exhaustPhysicalPlans(prop *property.PhysicalProperty) []PhysicalPlan {
if !prop.IsEmpty() {
return nil
}
mor := PhysicalMaxOneRow{}.Init(p.ctx, p.stats, &property.PhysicalProperty{ExpectedCnt: 2})
return []PhysicalPlan{mor}
}
| {'content_hash': 'c22be47591c7239de75e8374baff00e8', 'timestamp': '', 'source': 'github', 'line_count': 924, 'max_line_length': 195, 'avg_line_length': 35.06060606060606, 'alnum_prop': 0.7276206939128288, 'repo_name': 'mccxj/tidb', 'id': '67afd825f923b1dc46ceee9aa6b5f2467c24f960', 'size': '32911', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'planner/core/exhaust_physical_plans.go', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Dockerfile', 'bytes': '629'}, {'name': 'Go', 'bytes': '7562445'}, {'name': 'Makefile', 'bytes': '5675'}, {'name': 'Shell', 'bytes': '11200'}]} |
listing-bytestring
==================
listing instance for bytestring | {'content_hash': 'fba0b08bf7a9f969cdbeb4d1c1be5ca4', 'timestamp': '', 'source': 'github', 'line_count': 4, 'max_line_length': 31, 'avg_line_length': 17.5, 'alnum_prop': 0.6428571428571429, 'repo_name': 'nanonaren/listing-bytestring', 'id': '41a800072d3d1410fab06bce4c80611ba25a1027', 'size': '70', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'README.md', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'Haskell', 'bytes': '1144'}]} |
package org.apache.ode.bpel.memdao;
import org.apache.ode.bpel.common.ProcessState;
import org.apache.ode.bpel.evt.ProcessInstanceEvent;
import org.apache.ode.bpel.iapi.ProcessConf.CLEANUP_CATEGORY;
import org.apache.ode.dao.bpel.ActivityRecoveryDAO;
import org.apache.ode.dao.bpel.BpelDAOConnection;
import org.apache.ode.dao.bpel.CorrelationSetDAO;
import org.apache.ode.dao.bpel.CorrelatorDAO;
import org.apache.ode.dao.bpel.FaultDAO;
import org.apache.ode.dao.bpel.MessageExchangeDAO;
import org.apache.ode.dao.bpel.ProcessDAO;
import org.apache.ode.dao.bpel.ProcessInstanceDAO;
import org.apache.ode.dao.bpel.ScopeDAO;
import org.apache.ode.dao.bpel.XmlDataDAO;
import org.apache.ode.utils.QNameUtils;
import org.w3c.dom.Element;
import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A very simple, in-memory implementation of the {@link ProcessInstanceDAO}
* interface.
*/
public class ProcessInstanceDaoImpl extends DaoBaseImpl implements ProcessInstanceDAO {
private static final Collection<ScopeDAO> EMPTY_SCOPE_DAOS = Collections.emptyList();
private short _previousState;
private short _state;
private Long _instanceId;
private ProcessDaoImpl _processDao;
private Object _soup;
private Map<Long, ScopeDAO> _scopes = new HashMap<Long, ScopeDAO>();
private Map<String, List<ScopeDAO>> _scopesByName = new HashMap<String, List<ScopeDAO>>();
private Map<String, byte[]> _messageExchanges = new HashMap<String, byte[]>();
private ScopeDAO _rootScope;
private FaultDAO _fault;
private CorrelatorDAO _instantiatingCorrelator;
private BpelDAOConnection _conn;
private int _failureCount;
private Date _failureDateTime;
private Map<String, ActivityRecoveryDAO> _activityRecoveries = new HashMap<String, ActivityRecoveryDAO>();
// TODO: Remove this, we should be using the main event store...
private List<ProcessInstanceEvent> _events = new ArrayList<ProcessInstanceEvent>();
private Date _lastActive;
private int _seq;
ProcessInstanceDaoImpl(BpelDAOConnection conn, ProcessDaoImpl processDao, CorrelatorDAO correlator) {
_state = 0;
_processDao = processDao;
_instantiatingCorrelator = correlator;
_soup = null;
_instanceId = IdGen.newProcessId();
_conn = conn;
}
public XmlDataDAO[] getVariables(String variableName, int scopeModelId) {
ArrayList<XmlDataDAO> res = new ArrayList<XmlDataDAO>();
for (ScopeDAO scope : _scopes.values()) {
if (scope.getModelId() == scopeModelId) {
XmlDataDAO xmld = scope.getVariable(variableName);
if (xmld != null)
res.add(xmld);
}
}
return res.toArray(new XmlDataDAO[res.size()]);
}
public Set<CorrelationSetDAO> getCorrelationSets() {
HashSet<CorrelationSetDAO> res = new HashSet<CorrelationSetDAO>();
for (ScopeDAO scopeDAO : _scopes.values()) {
res.addAll(scopeDAO.getCorrelationSets());
}
return res;
}
public CorrelationSetDAO getCorrelationSet(String name) {
for (ScopeDAO scopeDAO : _scopes.values()) {
if (scopeDAO.getCorrelationSet(name) != null)
return scopeDAO.getCorrelationSet(name);
}
return null;
}
public void setFault(QName name, String explanation, int lineNo, int activityId, Element faultData) {
_fault = new FaultDaoImpl(QNameUtils.fromQName(name), explanation, faultData, lineNo, activityId);
}
public void setFault(FaultDAO fault) {
_fault = fault;
}
public FaultDAO getFault() {
return _fault;
}
/**
* @see ProcessInstanceDAO#getExecutionState()
*/
public byte[] getExecutionState() {
throw new IllegalStateException("In-memory instances are never serialized");
}
public void setExecutionState(byte[] bytes) {
throw new IllegalStateException("In-memory instances are never serialized");
}
public Object getSoup() {
return _soup;
}
public void setSoup(Object soup) {
_soup = soup;
}
public byte[] getMessageExchange(String identifier) {
byte[] mex = _messageExchanges.get(identifier);
assert (mex != null);
return mex;
}
/**
* @see ProcessInstanceDAO#getProcess()
*/
public ProcessDAO getProcess() {
return _processDao;
}
/**
* @see ProcessInstanceDAO#getRootScope()
*/
public ScopeDAO getRootScope() {
return _rootScope;
}
/**
* @see ProcessInstanceDAO#setState(short)
*/
public void setState(short state) {
_previousState = _state;
_state = state;
if (state == ProcessState.STATE_TERMINATED) {
for (CorrelatorDAO correlatorDAO : _processDao.getCorrelators()) {
correlatorDAO.removeRoutes(null, this);
}
}
}
/**
* @see ProcessInstanceDAO#getState()
*/
public short getState() {
return _state;
}
public void addMessageExchange(String identifier, byte[] data) {
assert (!_messageExchanges.containsKey(identifier));
_messageExchanges.put(identifier, data);
}
public ScopeDAO createScope(ScopeDAO parentScope, String scopeType, int scopeModelId) {
ScopeDaoImpl newScope = new ScopeDaoImpl(this, parentScope, scopeType, scopeModelId);
_scopes.put(newScope.getScopeInstanceId(), newScope);
List<ScopeDAO> namedScopes = _scopesByName.get(scopeType);
if (namedScopes == null) {
namedScopes = new LinkedList<ScopeDAO>();
_scopesByName.put(scopeType, namedScopes);
}
namedScopes.add(newScope);
if (parentScope == null) {
assert _rootScope == null;
_rootScope = newScope;
}
return newScope;
}
public Long getInstanceId() {
return _instanceId;
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#getScope(java.lang.Long)
*/
public ScopeDAO getScope(Long scopeInstanceId) {
return _scopes.get(scopeInstanceId);
}
public List<ProcessInstanceEvent> getEvents(int idx, int count) {
int sidx = Math.max(idx, 0);
sidx = Math.min(sidx, _events.size() - 1);
int eidx = Math.min(sidx + count, _events.size());
return _events.subList(sidx, eidx);
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#insertBpelEvent(org.apache.ode.bpel.evt.ProcessInstanceEvent)
*/
public void insertBpelEvent(ProcessInstanceEvent event) {
_events.add(event);
}
public int getEventCount() {
return _events.size();
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#getInstantiatingCorrelator()
*/
public CorrelatorDAO getInstantiatingCorrelator() {
return _instantiatingCorrelator;
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#getScopes(java.lang.String)
*/
public Collection<ScopeDAO> getScopes(String scopeName) {
List<ScopeDAO> scopes = _scopesByName.get(scopeName);
return (scopes == null ? EMPTY_SCOPE_DAOS : scopes);
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#getPreviousState()
*/
public short getPreviousState() {
return _previousState;
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#getLastActiveTime()
*/
public Date getLastActiveTime() {
return _lastActive;
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#setLastActiveTime(java.util.Date)
*/
public void setLastActiveTime(Date dt) {
_lastActive = dt;
}
/**
* @see org.apache.ode.dao.bpel.ProcessInstanceDAO#finishCompletion()
*/
public void finishCompletion() {
// make sure we have completed.
assert (ProcessState.isFinished(this.getState()));
// let our process know that we've done our work.
this.getProcess().instanceCompleted(this);
}
public void delete(Set<CLEANUP_CATEGORY> cleanupCategories) {
delete(cleanupCategories, true);
}
public void delete(Set<CLEANUP_CATEGORY> cleanupCategories, boolean deleteMyRoleMex) {
_processDao._instances.remove(_instanceId);
}
public Collection<ScopeDAO> getScopes() {
return _scopes.values();
}
public EventsFirstLastCountTuple getEventsFirstLastCount() {
EventsFirstLastCountTuple ret = new EventsFirstLastCountTuple();
ret.count = _events.size();
Date first = new Date();
Date last = new Date(0);
for (ProcessInstanceEvent event : _events) {
if (event.getTimestamp().before(first))
first = event.getTimestamp();
if (event.getTimestamp().after(last))
last = event.getTimestamp();
}
ret.first = first;
ret.last = last;
return ret;
}
public int getActivityFailureCount() {
return _failureCount;
}
public Date getActivityFailureDateTime() {
return _failureDateTime;
}
public Collection<ActivityRecoveryDAO> getActivityRecoveries() {
return _activityRecoveries.values();
}
public void createActivityRecovery(String channel, long activityId, String reason, Date dateTime, Element data,
String[] actions, int retries) {
_activityRecoveries
.put(channel, new ActivityRecoveryDAOImpl(channel, activityId, reason, dateTime, data, actions, retries));
_failureCount = _activityRecoveries.size();
_failureDateTime = dateTime;
}
public void deleteActivityRecovery(String channel) {
_activityRecoveries.remove(channel);
_failureCount = _activityRecoveries.size();
}
public synchronized long genMonotonic() {
return ++_seq;
}
static class ActivityRecoveryDAOImpl implements ActivityRecoveryDAO {
private long _activityId;
private String _channel;
private String _reason;
private Element _details;
private Date _dateTime;
private String _actions;
private int _retries;
ActivityRecoveryDAOImpl(String channel, long activityId, String reason, Date dateTime, Element details, String[] actions,
int retries) {
_activityId = activityId;
_channel = channel;
_reason = reason;
_details = details;
_dateTime = dateTime;
_actions = actions[0];
for (int i = 1; i < actions.length; ++i)
_actions += " " + actions[i];
_retries = retries;
}
public long getActivityId() {
return _activityId;
}
public String getChannel() {
return _channel;
}
public String getReason() {
return _reason;
}
public Element getDetails() {
return _details;
}
public Date getDateTime() {
return _dateTime;
}
public String getActions() {
return _actions;
}
public String[] getActionsList() {
return _actions.split(" ");
}
public int getRetries() {
return _retries;
}
}
void removeRoutes(String routeGroupId) {
for (CorrelatorDaoImpl correlator : _processDao._correlators.values())
correlator._removeRoutes(routeGroupId, this);
}
public BpelDAOConnection getConnection() {
return _conn;
}
public String toString() {
return "mem.instance(type=" + _processDao.getType() + " iid=" + _instanceId + ")";
}
public Collection<String> getMessageExchangeIds() {
return _messageExchanges.keySet();
}
}
| {'content_hash': '0ffeaded8ab79f0a9e1b7b546c786994', 'timestamp': '', 'source': 'github', 'line_count': 401, 'max_line_length': 129, 'avg_line_length': 30.468827930174562, 'alnum_prop': 0.6341463414634146, 'repo_name': 'riftsaw/riftsaw-ode', 'id': 'c25bd46cdb69f61965a908d628b8fdb1ea82dc46', 'size': '13026', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'bpel-runtime/src/main/java/org/apache/ode/bpel/memdao/ProcessInstanceDaoImpl.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'HTML', 'bytes': '14386'}, {'name': 'Java', 'bytes': '3864567'}, {'name': 'XSLT', 'bytes': '4334'}]} |
package factory.company;
import factory.project.SoftwareProject;
public abstract class SWCompnay {
// Factory method let child imp
protected abstract SoftwareProject createSoftwareProject(String type);
public SoftwareProject releaseSoftwareProject(String type){
SoftwareProject mSoftwareProject;
mSoftwareProject = createSoftwareProject(type);
mSoftwareProject.prepare();
mSoftwareProject.Run();
return mSoftwareProject;
}
}
| {'content_hash': '41dfb83e42cc789ded1de07f2ab4e883', 'timestamp': '', 'source': 'github', 'line_count': 17, 'max_line_length': 71, 'avg_line_length': 26.058823529411764, 'alnum_prop': 0.8126410835214447, 'repo_name': 'DeyuGoGo/EasyJavaDesignPatterns', 'id': '7a2387b030749e7c53c30b57dbcb4625e8751d23', 'size': '443', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'HeadFirstDesignPatterns/src/factory/company/SWCompnay.java', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Java', 'bytes': '49506'}]} |
package com.restfb.types.instagram;
import java.util.Date;
import com.restfb.Facebook;
import com.restfb.types.FacebookType;
import lombok.Getter;
import lombok.Setter;
public class IgMediaChild extends FacebookType {
private static final long serialVersionUID = 1L;
@Getter
@Setter
@Facebook("ig_id")
private String igId;
/**
* Media type. Can be CAROUSEL_ALBUM, IMAGE, or VIDEO.
*/
@Getter
@Setter
@Facebook("media_type")
private String mediaType;
/**
* Media URL. Will be omitted from responses if the media contains copyrighted material, or has been flagged for a
* copyright violation.
*/
@Getter
@Setter
@Facebook("media_url")
private String mediaUrl;
/**
* Surface where the media is published. Can be AD, FEED, or STORY.
*/
@Getter
@Setter
@Facebook("media_product_type")
private String mediaProductType;
/**
* ID of Instagram user who created the media. Only returned if the app user making the query also created the media,
* otherwise <code>username</code> field will be returned instead.
*
* @deprecated with Graph API 12 or December 13, 2021 for all versions
*/
@Getter
@Setter
@Facebook
@Deprecated
private IgUser owner;
/**
* Permanent URL to the media.
*/
@Getter
@Setter
@Facebook
private String permalink;
/**
* Shortcode to the media.
*/
@Getter
@Setter
@Facebook
private String shortcode;
/**
* Media thumbnail URL. Only available on VIDEO media.
*/
@Getter
@Setter
@Facebook("thumbnail_url")
private String thumbnailUrl;
/**
* ISO 8601 formatted creation date in UTC (default is UTC ±00:00)
*/
@Getter
@Setter
@Facebook
private Date timestamp;
/**
* Username of user who created the media.
*/
@Getter
@Setter
@Facebook
private String username;
}
| {'content_hash': '3ba951a33e1329ccb33dcfa330ecc048', 'timestamp': '', 'source': 'github', 'line_count': 97, 'max_line_length': 119, 'avg_line_length': 19.082474226804123, 'alnum_prop': 0.678011885467315, 'repo_name': 'restfb/restfb', 'id': '42492b93e2887285b8c3e26a227ea279939cdd20', 'size': '2989', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/main/lombok/com/restfb/types/instagram/IgMediaChild.java', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Java', 'bytes': '2869223'}]} |
package com.gdn.venice.server.app.finance.presenter.commands;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import com.djarum.raf.utilities.JPQLAdvancedQueryCriteria;
import com.djarum.raf.utilities.Locator;
import com.gdn.venice.client.app.DataNameTokens;
import com.gdn.venice.facade.FinPeriodSessionEJBRemote;
import com.gdn.venice.persistence.FinPeriod;
import com.gdn.venice.server.command.RafDsCommand;
import com.gdn.venice.server.data.RafDsRequest;
import com.gdn.venice.server.data.RafDsResponse;
/**
*This is Datasource-style presenter command use for fetching period data
*
* <p>
* <b>author:</b> <a href="mailto:[email protected]">Christian Suwuh</a>
* <p>
* <b>version:</b> 1.0
* <p>
* <b>since:</b> 2011
*
*/
public class FetchPeriodDataCommand implements RafDsCommand {
RafDsRequest request;
/**
* Basic constructor for Fetch Period data
* @param request
*/
public FetchPeriodDataCommand(RafDsRequest rafDsRequest) {
this.request = rafDsRequest;
}
/* (non-Javadoc)
* @see com.gdn.venice.server.command.RafDsCommand#execute()
*/
@Override
public RafDsResponse execute() {
RafDsResponse rafDsResponse = new RafDsResponse();
List<HashMap<String, String>> dataList= new ArrayList<HashMap<String, String>>();
Locator<FinPeriod> periodLocator=null;
try{
periodLocator = new Locator<FinPeriod>();
FinPeriodSessionEJBRemote finPeriodSessionHome = (FinPeriodSessionEJBRemote) periodLocator.lookup(FinPeriodSessionEJBRemote.class, "FinPeriodSessionEJBBean");
/*
* This is the list that will be used to fetch the periods
*/
List<FinPeriod> finPeriodList = null;
JPQLAdvancedQueryCriteria criteria = request.getCriteria();
if (criteria == null) {
String query = "select o from FinPeriod o";
finPeriodList = finPeriodSessionHome.queryByRange(query, 0, 50);
} else {
FinPeriod finPeriod = new FinPeriod();
finPeriodList = finPeriodSessionHome.findByFinPeriodLike(finPeriod, criteria, 0, 0);
}
/*
* Map the data into a map for populating the dataList
*/
for(FinPeriod period:finPeriodList){
HashMap<String, String> map = new HashMap<String, String>();
map.put(DataNameTokens.FINPERIOD_PERIODID, period.getPeriodId()!=null?period.getPeriodId().toString():"");
map.put(DataNameTokens.FINPERIOD_PERIODDESC, period.getPeriodDesc()!=null?period.getPeriodDesc():"");
map.put(DataNameTokens.FINPERIOD_FROMDATETIME, period.getFromDatetime()!=null?period.getFromDatetime().toString():"");
map.put(DataNameTokens.FINPERIOD_TODATETIME, period.getToDatetime()!=null?period.getToDatetime().toString():"");
dataList.add(map);
}
/*
* Initialize the data source response settings
*/
rafDsResponse.setStatus(0);
rafDsResponse.setStartRow(request.getStartRow());
rafDsResponse.setTotalRows(finPeriodList.size());
rafDsResponse.setEndRow(request.getStartRow()+finPeriodList.size());
}catch(Exception e){
e.printStackTrace();
rafDsResponse.setStatus(-1);
}finally{
try{
if(periodLocator!=null){
periodLocator.close();
}
}catch(Exception e){
e.printStackTrace();
}
}
rafDsResponse.setData(dataList);
return rafDsResponse;
}
} | {'content_hash': '00d30a512380c14df3702edd74ae67a8', 'timestamp': '', 'source': 'github', 'line_count': 106, 'max_line_length': 161, 'avg_line_length': 31.0188679245283, 'alnum_prop': 0.7271897810218978, 'repo_name': 'yauritux/venice-legacy', 'id': '33e42b6f905b122dc3140660b9e7eb6182ed1331', 'size': '3288', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'Venice/Venice-Web/src/main/java/com/gdn/venice/server/app/finance/presenter/commands/FetchPeriodDataCommand.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'ASP', 'bytes': '270052'}, {'name': 'ActionScript', 'bytes': '241582'}, {'name': 'C#', 'bytes': '77780'}, {'name': 'CSS', 'bytes': '281718'}, {'name': 'Java', 'bytes': '19297374'}, {'name': 'JavaScript', 'bytes': '426505'}, {'name': 'PHP', 'bytes': '443666'}, {'name': 'Perl', 'bytes': '1716'}, {'name': 'Ruby', 'bytes': '152554'}, {'name': 'Visual Basic', 'bytes': '71378'}, {'name': 'XSLT', 'bytes': '207588'}]} |
require "sidekiq/testing/inline"
require_relative "../../test/support/sidekiq_test_helpers"
World(SidekiqTestHelpers)
Around("@without-delay or @not-quite-as-fake-search") do |_scenario, block|
Sidekiq::Testing.inline! do
block.call
end
end
Around("@disable-sidekiq-test-mode") do |_scenario, block|
with_real_sidekiq do
block.call
end
end
| {'content_hash': '14db47d6e92ac1e9a95dd57b294023cb', 'timestamp': '', 'source': 'github', 'line_count': 16, 'max_line_length': 75, 'avg_line_length': 22.4375, 'alnum_prop': 0.7270194986072424, 'repo_name': 'alphagov/whitehall', 'id': '15199882ad39ef7529d55c7e88664205ed8c76fa', 'size': '359', 'binary': False, 'copies': '1', 'ref': 'refs/heads/main', 'path': 'features/support/sidekiq.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Dockerfile', 'bytes': '3039'}, {'name': 'Gherkin', 'bytes': '82444'}, {'name': 'HTML', 'bytes': '695467'}, {'name': 'JavaScript', 'bytes': '250602'}, {'name': 'Procfile', 'bytes': '117'}, {'name': 'Ruby', 'bytes': '5239261'}, {'name': 'SCSS', 'bytes': '180354'}, {'name': 'Shell', 'bytes': '3870'}]} |
import $ from 'jquery';
import * as Backbone from 'backbone';
import project_tpl from '../templates/project-tpl.js';
class ProjectView extends Backbone.View {
initialize(options) {
this.parentEl = options.parentEl;
// listeners
this.listenTo(this.model, 'view:remove', this.detach);
this.listenTo(this.model, 'view:restore', this.render);
let isActive = this.model.get("active") == "true";
var monthNames = ["January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
];
let startDateParts = /^(\d{4})-?(\d{2})?-?(\d{2})?/.exec(this.model.get("start"));
let startYear = startDateParts ? startDateParts[1] : null;
let startMonth = startDateParts ? startDateParts[2] : null;
let endDateParts = /^(\d{4})-?(\d{2})?-?(\d{2})?/.exec(this.model.get("end"));
let endYear = endDateParts ? endDateParts[1] : null;
let endMonth = endDateParts ? endDateParts[2] : null;
let startDate = "";
let endDate = "";
if (startYear && !startMonth){
startDate = startYear;
}
else if (startYear && startMonth) {
let month = monthNames[parseInt(startMonth)-1];
if (month) {
startDate = month + " ";
}
startDate += startYear;
}
if (endYear && !endMonth){
endDate = endYear;
}
else if (endYear && endMonth) {
let month = monthNames[parseInt(endMonth)-1];
if (month) {
endDate = month + " ";
}
endDate += endYear;
} else if (isActive) {
endDate += "present";
}
if (startDate){
let dateString = endDate ? startDate + " – " + endDate : startDate;
this.model.set("date", dateString);
}
}
render() {
this.model.set("attached", true);
this.$el.html(project_tpl(this.model.toJSON()));
return this.$el;
}
detach() {
this.model.set("attached", false);
this.$el.empty();
}
}
export default ProjectView; | {'content_hash': 'cab31ad588c83966210ba922ca229f17', 'timestamp': '', 'source': 'github', 'line_count': 68, 'max_line_length': 90, 'avg_line_length': 32.470588235294116, 'alnum_prop': 0.5276268115942029, 'repo_name': 'umd-mith/mith-research-explorer', 'id': '57123b550a91b821777780e0828df1f5aff18457', 'size': '2210', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/js/views/project-view.js', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '378100'}, {'name': 'HTML', 'bytes': '134222'}, {'name': 'JavaScript', 'bytes': '35173'}]} |
function [c1,c2]= oox(p1,p2,bounds,Ops)
% Orderbased crossover takes two parents P1,P2 and performs order
% based crossover by Davis.
%
% function [c1,c2] = orderbasedXover(p1,p2,bounds,Ops)
% p1 - the first parent ( [solution string function value] )
% p2 - the second parent ( [solution string function value] )
% bounds - the bounds matrix for the solution space
% Ops - Options matrix for simple crossover [gen #SimpXovers].
% Binary and Real-Valued Simulation Evolution for Matlab
% Copyright (C) 1996 C.R. Houck, J.A. Joines, M.G. Kay
%
% C.R. Houck, J.Joines, and M.Kay. A genetic algorithm for function
% optimization: A Matlab implementation. ACM Transactions on Mathmatical
% Software, Submitted 1996.
%
% This program is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 1, or (at your option)
% any later version.
%
% This program is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details. A copy of the GNU
% General Public License can be obtained from the
% Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
sz=size(p1,2)-1;
n=floor(sz/2);
cut1 = round(rand*(n-1)+0.5); %Generate random cut point U(1,n/2);
cut2 = round(rand*(sz-cut1-1)+1+cut1); %Generate random cut point U(cut1+1,n-1);
pm1=p1(1:end-1);
pm2=p2(1:end-1);
c1=p1;
c2=p2;
for i=[1:cut1 (cut2+1):sz]
pm1=strrep(pm1,p2(i),-1);
pm2=strrep(pm2,p1(i),-1);
end
c1((cut1+1):cut2)=p2(find(pm2>0));
c2((cut1+1):cut2)=p1(find(pm1>0));
| {'content_hash': 'b3acbd3907fe9717da8c4c00bff36a16', 'timestamp': '', 'source': 'github', 'line_count': 42, 'max_line_length': 80, 'avg_line_length': 41.45238095238095, 'alnum_prop': 0.7151062607696727, 'repo_name': 'xingshulicc/Using-Genetic-Algorithm-to-improve-Artificial-Neural-Network', 'id': 'a5a551b41324bf91808cc3dbc5ecb32aa5bfca92', 'size': '1741', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'gaot/orderbasedXover.m', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Matlab', 'bytes': '122238'}]} |
package org.deeplearning4j.text.corpora.treeparser;
import org.deeplearning4j.nn.layers.feedforward.autoencoder.recursive.Tree;
import org.deeplearning4j.text.corpora.treeparser.transformer.TreeTransformer;
import java.util.ArrayList;
import java.util.List;
/**
* Collapse unaries such that the
* tree is only made of preterminals and leaves.
*
* @author Adam Gibson
*/
public class CollapseUnaries implements TreeTransformer {
@Override
public Tree transform(Tree tree) {
if (tree.isPreTerminal() || tree.isLeaf()) {
return tree;
}
List<Tree> children = tree.children();
while (children.size() == 1 && !children.get(0).isLeaf()) {
children = children.get(0).children();
}
List<Tree> processed = new ArrayList<>();
for (Tree child : children)
processed.add(transform(child));
Tree ret = new Tree(tree);
ret.connect(processed);
return ret;
}
}
| {'content_hash': '224935f5e77a545e4c8069f5e0884752', 'timestamp': '', 'source': 'github', 'line_count': 43, 'max_line_length': 78, 'avg_line_length': 23.023255813953487, 'alnum_prop': 0.6454545454545455, 'repo_name': 'RobAltena/deeplearning4j', 'id': 'b01bd05f68e690d9495f34e0390c44891c3d7b01', 'size': '1751', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'deeplearning4j/deeplearning4j-nlp-parent/deeplearning4j-nlp-uima/src/main/java/org/deeplearning4j/text/corpora/treeparser/CollapseUnaries.java', 'mode': '33261', 'license': 'apache-2.0', 'language': [{'name': 'Batchfile', 'bytes': '2469'}, {'name': 'C', 'bytes': '144275'}, {'name': 'C#', 'bytes': '138404'}, {'name': 'C++', 'bytes': '16954560'}, {'name': 'CMake', 'bytes': '77377'}, {'name': 'CSS', 'bytes': '10363'}, {'name': 'Cuda', 'bytes': '2324886'}, {'name': 'Dockerfile', 'bytes': '1329'}, {'name': 'FreeMarker', 'bytes': '77045'}, {'name': 'HTML', 'bytes': '38914'}, {'name': 'Java', 'bytes': '36293636'}, {'name': 'JavaScript', 'bytes': '436278'}, {'name': 'PureBasic', 'bytes': '12256'}, {'name': 'Python', 'bytes': '325018'}, {'name': 'Ruby', 'bytes': '4558'}, {'name': 'Scala', 'bytes': '355054'}, {'name': 'Shell', 'bytes': '80490'}, {'name': 'Smarty', 'bytes': '900'}, {'name': 'Starlark', 'bytes': '931'}, {'name': 'TypeScript', 'bytes': '80252'}]} |
import React,{Component} from "react"
import {render} from 'react-dom'
import {connect} from 'react-redux'
import { bindActionCreators } from 'redux'
import * as actions from '../actions/index'
import { Layout } from 'antd';
import PostList from '../components/PostList';
import Page from '../components/Page';
import '../static/scss/main.scss';
class Main extends Component {
constructor(props) {
super(props);
}
componentDidMount(){
console.log('main componentDidMount');
var data = 'currentPage=1&pageSize=10';
this.props.actions.GetList(data,'initializePoster');
}
render() {
console.log('this.props.posterInfo is ',this.props.posterInfo);
if(this.props.posterInfo.posterInfo!==null){
if(this.props.posterInfo.posterInfo.length === 0){
return (
<div className='not_found'>
无相关记录，真的是NOT FOUND，不是404哦
</div>
);
}
else{
return (
<div className='main'>
<PostList posterInfo = {this.props.posterInfo.posterInfo}></PostList>
<Page></Page>
</div>
);
}
}
else{
return (
<div className='not_found'>
无相关记录，真的是NOT FOUND，不是404哦
</div>
);
}
}
}
const mapStateToProps = (state) => {
//console.log('Main.js mapStateToProps,state is ',state);
return {
posterInfo:state.stores.posterInfo
}
}
const mapDispatchToProps = (dispatch) => {
//console.log('Main.js mapDispatchToProps');
return {
actions: bindActionCreators(actions, dispatch),
}
}
export default connect(
mapStateToProps,
mapDispatchToProps
)(Main)
| {'content_hash': '33385625075d6c76c6bcc503f7a98e64', 'timestamp': '', 'source': 'github', 'line_count': 71, 'max_line_length': 81, 'avg_line_length': 23.549295774647888, 'alnum_prop': 0.6118421052631579, 'repo_name': 'kkltmoyu/NightPost', 'id': 'a0e6df5852444934d4c85c849ec4a1462d33f085', 'size': '1724', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'app/containers/Main.js', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '5724'}, {'name': 'HTML', 'bytes': '267'}, {'name': 'JavaScript', 'bytes': '613233'}, {'name': 'Shell', 'bytes': '486'}]} |
'''
Created on 23-Oct-2014
@author: Rahul
@summary: Main file to drive data collection, sentiment calculation, and
serialization.
'''
from integrations.twitter import Collector
from integrations.settings import TWITTER_CREDS, TWITTER_SEARCH_PARAMS,\
OUTPUT_FILE, FIELDS_TO_SAVE
from core.sentiment import get_sentiment_for_text
from serializers.csv import write
TWITTER_HANDLES = {
"microsoft": ["@microsoft", "@bing"]
}
def prepare_to_serialize(source, company, identifiers, text_sentiment):
'''
Prepares the data in the format that is convenient for serialization
'''
return {"source": source,
"company": company,
"identifiers": str(identifiers),
"created_at": text_sentiment[0],
"text": text_sentiment[1],
"sentiment": text_sentiment[2][0],
"p_pos": text_sentiment[2][1],
"p_neg": text_sentiment[2][2]
}
def sentiment_on_twitter(twitter_handles):
'''
Integrates twitter data and performs sentiment analysis.
'''
source = "twitter"
for company, handles in twitter_handles.items():
print "\n\n Processing: %s" % (handles)
print "Getting data from twitter.. "
tweets = Collector(TWITTER_CREDS).get_updates(handles, **TWITTER_SEARCH_PARAMS) # @IgnorePep8
print "Preparing data to serialize.. "
tweets = [(tweet.created_at, tweet.text.encode('utf-8'), get_sentiment_for_text(tweet.text.encode('utf-8'))) for tweet in tweets] # @IgnorePep8
print "Serializing data in CSV format.. "
ofile = OUTPUT_FILE
fields = FIELDS_TO_SAVE
tweets = [prepare_to_serialize(source, company, handles, tweet) for tweet in tweets] # @IgnorePep8
write(ofile, fields, tweets)
if __name__ == '__main__':
sentiment_on_twitter(TWITTER_HANDLES)
| {'content_hash': '635d7a73e9ab5d64e771a75961c31910', 'timestamp': '', 'source': 'github', 'line_count': 59, 'max_line_length': 152, 'avg_line_length': 31.76271186440678, 'alnum_prop': 0.6403415154749199, 'repo_name': 'tanwanirahul/sentiment-on-twitter', 'id': 'f4e466720b97d050154226f1cbf5b57b9ffffcd7', 'size': '1874', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/main.py', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Python', 'bytes': '4740'}]} |
package testdata
import "github.com/flexiant/concerto/api/types"
// GetCloudAccountData loads test data
func GetCloudAccountData() *[]types.CloudAccount {
testCloudAccounts := []types.CloudAccount{
{
Id: "fakeID0",
CloudProvId: "fakeProvID0",
},
{
Id: "fakeID1",
CloudProvId: "fakeProvID1",
},
}
return &testCloudAccounts
}
| {'content_hash': '884b2ff4117bb9004bec78b9dec0cd83', 'timestamp': '', 'source': 'github', 'line_count': 20, 'max_line_length': 50, 'avg_line_length': 18.45, 'alnum_prop': 0.6639566395663956, 'repo_name': 'flexiant/concerto', 'id': '848a7fc6dc5338956a31f058e5f71699080c728c', 'size': '369', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'testdata/cloud_accounts_data.go', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Cucumber', 'bytes': '4087'}, {'name': 'Go', 'bytes': '344726'}, {'name': 'Shell', 'bytes': '10235'}]} |
<?xml version="1.0" encoding="utf-8"?>
<TextView
android:id="@+id/txt_country"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center_vertical"
android:padding="16dp"
android:textColor="@color/primary_text"
android:textSize="16sp"
android:drawablePadding="20dp"/> | {'content_hash': '56387da1583058d7c0564296a8ad98ce', 'timestamp': '', 'source': 'github', 'line_count': 12, 'max_line_length': 62, 'avg_line_length': 33.416666666666664, 'alnum_prop': 0.7007481296758105, 'repo_name': 'AnkitAggarwalPEC/plumApp', 'id': '745adaf878eccddae3b60670d924009da5f51387', 'size': '401', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'app/src/main/res/layout/list_item_search.xml', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '214905'}]} |
package runner_test
import (
"errors"
"runtime"
"syscall"
"testing"
"time"
"github.com/ardanlabs/kit/runner"
)
// Success and failure markers.
var (
success = "\u2713"
failed = "\u2717"
)
//==============================================================================
// task represents a test task.
type task struct {
kill chan bool
err error
}
// Job is the implementation of the Jobber interface.
func (t *task) Job(traceID string) error {
// Pretend you are doing work for the specified
// amount of time.
<-t.kill
// Report we received the signal to keep things in
// sync between test functions.
t.kill <- true
return t.err
}
// Kill will kill the Job method immediately.
func (t *task) Kill() {
select {
case t.kill <- true:
// If we were able to send the message, wait
// for the response to keep things in sync.
<-t.kill
default:
}
}
// KillAfter will kill the Job method after the specified duration.
func (t *task) KillAfter(dur time.Duration) {
t.kill = make(chan bool)
go func() {
time.Sleep(dur)
t.Kill()
}()
runtime.Gosched()
}
//==============================================================================
// TestCompleted tests when jobs complete properly.
func TestCompleted(t *testing.T) {
t.Log("Given the need to test a successful task run.")
{
t.Log("\tWhen using a task that will complete in time.")
{
var job task
job.KillAfter(time.Millisecond)
r := runner.New(time.Second)
if err := r.Run("traceID", &job); err != nil {
t.Fatalf("\t%s\tShould not receive an error : %v", failed, err)
}
t.Logf("\t%s\tShould not receive an error.", success)
}
}
}
// TestError tests when jobs complete properly but with errors.
func TestError(t *testing.T) {
t.Log("Given the need to test a successful task run with error.")
{
t.Log("\tWhen using a task that will complete in time.")
{
job := task{
err: errors.New("Error"),
}
job.KillAfter(time.Millisecond)
r := runner.New(time.Second)
if err := r.Run("traceID", &job); err == nil {
t.Fatalf("\t%s\tShould receive our error : %v", failed, err)
}
t.Logf("\t%s\tShould receive our error.", success)
}
}
}
// TestTimeout tests when jobs timeout.
func TestTimeout(t *testing.T) {
t.Log("Given the need to test a task that timesout.")
{
t.Log("\tWhen using a task that will timeout.")
{
var job task
job.KillAfter(time.Second)
// Need the job method to quit as soon as we are done.
defer job.Kill()
r := runner.New(time.Millisecond)
if err := r.Run("traceID", &job); err != runner.ErrTimeout {
t.Fatalf("\t%s\tShould receive a timeout error : %v", failed, err)
}
t.Logf("\t%s\tShould receive a timeout error.", success)
}
}
}
// TestSignaled tests when jobs is requested to shutdown.
func TestSignaled(t *testing.T) {
t.Log("Given the need to test a task that is requested to shutdown.")
{
t.Log("\tWhen using a task that should see the signal.")
{
var job task
job.KillAfter(100 * time.Millisecond)
// Need the job method to quit as soon as we are done.
defer job.Kill()
go func() {
time.Sleep(50 * time.Millisecond)
syscall.Kill(syscall.Getpid(), syscall.SIGINT)
}()
r := runner.New(3 * time.Second)
if err := r.Run("traceID", &job); err != nil {
t.Errorf("\t%s\tShould receive no error : %v", failed, err)
} else {
t.Logf("\t%s\tShould receive no error.", success)
}
if !r.CheckShutdown() {
t.Errorf("\t%s\tShould show the check shutdown flag is set.", failed)
} else {
t.Logf("\t%s\tShould show the check shutdown flag is set.", success)
}
}
}
}
| {'content_hash': 'bd61a1eff3ae9544506ae8a87cc0a03b', 'timestamp': '', 'source': 'github', 'line_count': 159, 'max_line_length': 80, 'avg_line_length': 22.968553459119498, 'alnum_prop': 0.6185651697699891, 'repo_name': 'ardanlabs/kit', 'id': '287554933ac1ef331096d7e7d522d14b4533f923', 'size': '3652', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'runner/runner_test.go', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Go', 'bytes': '204231'}, {'name': 'Shell', 'bytes': '449'}]} |
if (self.selectedChangeBlock) {\
__weak typeof(self)weakSelf = self;\
self.selectedChangeBlock(weakSelf,[weakSelf currentSelected],self.identifier);\
}\
#define __set__property(value) \
_##value = value;\
self.manager.value = value;\
#pragma mark --- DWCheckBoxView ---
@interface DWCheckBoxView ()
///管理者
@property (nonatomic ,strong) DWCheckBoxManager * manager;
@property (nonatomic ,strong) DWCheckBoxLayout * layout;
@end
@implementation DWCheckBoxView
@synthesize selectedImage = _selectedImage;
@synthesize unSelectedImage = _unSelectedImage;
+(NSArray<UIView<DWCheckBoxCellProtocol> *> *)cellsFromTitles:(NSArray<NSString *> *)titles
{
NSMutableArray * arr = [NSMutableArray array];
[titles enumerateObjectsUsingBlock:^(NSString * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
DWCheckBoxDefaultCell * cell = [DWCheckBoxDefaultCell cellWithTitle:obj];
[arr addObject:cell];
}];
return arr;
}
-(instancetype)initWithFrame:(CGRect)frame layout:(DWCheckBoxLayout *)layout manager:(DWCheckBoxManager *)manager multiSelect:(BOOL)multiSelect cells:(NSArray<UIView<DWCheckBoxCellProtocol>*> *)cells
{
self = [super initWithFrame:frame];
if (self) {
[self initValueWithMultiSelect:multiSelect cells:cells manager:manager layout:layout];
}
return self;
}
-(instancetype)initWithFrame:(CGRect)frame multiSelect:(BOOL)multiSelect cells:(NSArray<UIView<DWCheckBoxCellProtocol>*> *)cells defaultSelect:(NSArray<NSNumber *> *)defaultSelect
{
self = [super initWithFrame:frame];
if (self) {
[self initValueWithMultiSelect:multiSelect cells:cells manager:[self getDefaultManagerWithCells:cells multiSelect:multiSelect defaultSelect:defaultSelect] layout:[DWCheckBoxDefaultLayout new]];
}
return self;
}
-(instancetype)initWithFrame:(CGRect)frame layout:(DWCheckBoxLayout *)layout multiSelect:(BOOL)multiSelect cells:(NSArray<UIView<DWCheckBoxCellProtocol> *> *)cells defaultSelect:(NSArray<NSNumber *> *)defaultSelect
{
return [self initWithFrame:frame layout:layout manager:[self getDefaultManagerWithCells:cells multiSelect:multiSelect defaultSelect:defaultSelect] multiSelect:multiSelect cells:cells];
}
-(instancetype)initWithFrame:(CGRect)frame multiSelect:(BOOL)multiSelect titles:(NSArray<NSString *> *)titles defaultSelect:(NSArray<NSNumber *> *)defaultSelect
{
return [self initWithFrame:frame multiSelect:multiSelect cells:[DWCheckBoxView cellsFromTitles:titles] defaultSelect:defaultSelect];
}
-(instancetype)initWithFrame:(CGRect)frame layout:(DWCheckBoxLayout *)layout multiSelect:(BOOL)multiSelect titles:(NSArray<NSString *> *)titles defaultSelect:(NSArray<NSNumber *> *)defaultSelect
{
NSArray * cells = [DWCheckBoxView cellsFromTitles:titles];
return [self initWithFrame:frame layout:layout multiSelect:multiSelect cells:cells defaultSelect:defaultSelect];
}
-(void)selectAtIndex:(NSUInteger)idx
{
[self.manager selectAtIndex:idx];
}
-(void)selectAll
{
[self.manager selectAll];
}
-(void)deselectAtIndex:(NSUInteger)idx
{
[self.manager deselectAtIndex:idx];
}
-(void)deselectAll
{
[self.manager deselectAll];
}
#pragma mark --- Tool Method ---
-(DWCheckBoxManager *)getDefaultManagerWithCells:(NSArray <UIView<DWCheckBoxCellProtocol>*>*)cells
multiSelect:(BOOL)multiSelect
defaultSelect:(NSArray <NSNumber *>*)defaultSelect
{
__weak typeof(self)weakSelf = self;
DWCheckBoxManager * manager = [[DWCheckBoxManager alloc] initWithCountOfBoxes:cells.count multiSelect:multiSelect defaultSelect:defaultSelect selectedChangeBlock:^(DWCheckBoxManager * mgr,id currentSelect, NSString *identifier) {
NSArray * arr = nil;
if (currentSelect) {
if (!weakSelf.multiSelect) {
arr = @[currentSelect];
}
else
{
arr = currentSelect;
}
}
[self handleCells:cells withArr:arr manager:mgr];
}];
return manager;
}
-(void)initValueWithMultiSelect:(BOOL)multiSelect
cells:(NSArray <UIView<DWCheckBoxCellProtocol>*>*)cells
manager:(DWCheckBoxManager *)manager
layout:(DWCheckBoxLayout *)layout
{
_manager = manager;
_layout = layout;
_countOfBoxes = cells.count;
_multiSelect = multiSelect;
_cells = cells;
[self handleCellsWithAction];
}
-(void)layoutSubviews
{
[super layoutSubviews];
[self.layout layoutCheckBoxView:self cells:self.cells];
NSArray * arr = nil;
arr = (!self.manager.currentSelected)?nil:_multiSelect?self.manager.currentSelected:@[self.manager.currentSelected];
[self handleCells:self.cells withArr:arr manager:self.manager];
}
-(void)handleCells:(NSArray<UIView<DWCheckBoxCellProtocol>*> *)cells
withArr:(NSArray *)arr
manager:(DWCheckBoxManager *)mgr
{
[cells enumerateObjectsUsingBlock:^(UIView<DWCheckBoxCellProtocol> * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
if ([arr containsObject:@(idx)]) {
[obj cellBeSelected:YES withImage:mgr.selectedImage];
}
else
{
[obj cellBeSelected:NO withImage:mgr.unSelectedImage];
}
}];
}
-(void)handleCellsWithAction
{
__weak typeof(self)weakSelf = self;
[self.cells enumerateObjectsUsingBlock:^(UIView<DWCheckBoxCellProtocol> * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
obj.selectedBlock = ^(BOOL isSelect,UIView<DWCheckBoxCellProtocol> * view){
NSUInteger idx = [weakSelf.cells indexOfObject:view];
if (isSelect) {
[weakSelf.manager deselectAtIndex:idx];
}
else
{
[weakSelf.manager selectAtIndex:idx];
}
};
}];
}
#pragma mark --- setter/getter ---
-(void)setCountOfBoxes:(NSUInteger)countOfBoxes {
__set__property(countOfBoxes)
}
-(void)setMultiSelect:(BOOL)multiSelect
{
__set__property(multiSelect)
}
-(void)setSelectedImage:(UIImage *)selectedImage
{
__set__property(selectedImage)
}
-(void)setUnSelectedImage:(UIImage *)unSelectedImage
{
__set__property(unSelectedImage)
}
-(id)currentSelected
{
return self.manager.currentSelected;
}
-(UIImage *)selectedImage
{
if (!_selectedImage) {
return self.manager.selectedImage;
}
return _selectedImage;
}
-(UIImage *)unSelectedImage
{
if (!_unSelectedImage) {
return self.manager.unSelectedImage;
}
return _unSelectedImage;
}
@end
#pragma mark --- DWCheckBoxLayout ---
@implementation DWCheckBoxLayout
-(void)layoutCheckBoxView:(UIView *)checkBoxView cells:(NSArray<id<DWCheckBoxCellProtocol>> *)cells
{
NSLog(@"you should use subClass of DWCheckLayout and implement this method by yourself");
}
@end
#pragma mark --- DWCheckBoxDefaultLayout ---
@implementation DWCheckBoxDefaultLayout
-(void)layoutCheckBoxView:(UIView *)checkBoxView cells:(NSArray<UIView<DWCheckBoxCellProtocol>*> *)cells
{
CGRect frame = checkBoxView.frame;
CGFloat width = frame.size.width;
CGFloat height = frame.size.height;
__block CGFloat originX = 0;
__block CGFloat originY = 0;
[cells enumerateObjectsUsingBlock:^(UIView<DWCheckBoxCellProtocol> * obj, NSUInteger idx, BOOL * _Nonnull stop) {
if ((originX + obj.bounds.size.width + 5) > width) {
if (originX == 0) {
CGRect objF = obj.frame;
CGSize objS = objF.size;
objS.width = width;
objF.size = objS;
obj.frame = objF;
} else if ((originY + self.spacing + obj.frame.size.height) < height) {
originX = 0;
originY += self.spacing + obj.frame.size.height;
}
else
{
*stop = YES;
}
}
if (!*stop) {
CGPoint origin = CGPointMake(originX, originY);
CGRect frame = obj.frame;
frame.origin = origin;
obj.frame = frame;
[checkBoxView addSubview:obj];
originX += obj.bounds.size.width + self.spacing;
}
}];
}
-(instancetype)init
{
self = [super init];
if (self) {
self.spacing = -1;
}
return self;
}
-(CGFloat)spacing
{
if (_spacing == -1) {
return 5;
}
return _spacing;
}
@end
#pragma mark --- DWCheckBoxDefaultCell ---
@implementation DWCheckBoxDefaultCell
@synthesize isSelected,selectedBlock;
+(instancetype)cellWithTitle:(NSString *)title
{
DWCheckBoxDefaultCell * btn = [self buttonWithType:(UIButtonTypeCustom)];
if (btn) {
[btn setTitle:title forState:(UIControlStateNormal)];
}
return btn;
}
+(instancetype)buttonWithType:(UIButtonType)buttonType
{
DWCheckBoxDefaultCell * btn = [super buttonWithType:buttonType];
if (btn) {
btn.contentHorizontalAlignment = UIControlContentHorizontalAlignmentLeft;
btn.titleLabel.lineBreakMode = NSLineBreakByTruncatingTail;
[btn setTitleColor:[UIColor blackColor] forState:(UIControlStateNormal)];
[btn addTarget:btn action:@selector(buttonAction:) forControlEvents:(UIControlEventTouchUpInside)];
}
return btn;
}
-(void)buttonAction:(id)sender
{
if (self.selectedBlock) {
__weak typeof(self)weakSelf = self;
self.selectedBlock(self.isSelected,weakSelf);
}
}
-(void)setFrame:(CGRect)frame
{
[super setFrame:frame];
CGFloat height = frame.size.height;
height = height > 44?44:height;
self.imageEdgeInsets = UIEdgeInsetsMake(0, 0, 0, frame.size.width - height);
self.titleEdgeInsets = UIEdgeInsetsMake(0, height - 39, 0, 0);
}
-(void)cellBeSelected:(BOOL)selected withImage:(UIImage *)image
{
self.isSelected = selected;
[self setImage:image forState:(UIControlStateNormal)];
}
-(void)setTitle:(NSString *)title forState:(UIControlState)state
{
[super setTitle:title forState:state];
[self sizeToFit];
}
-(void)sizeToFit
{
UILabel * label = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 100, 100)];
label.text = self.titleLabel.text;
label.font = self.titleLabel.font;
[label sizeToFit];
CGRect frame = self.frame;
CGSize size = CGSizeZero;
size.height = label.frame.size.height;
size.width = size.height + 5 + label.bounds.size.width;
frame.size = size;
self.frame = frame;
}
@end
#pragma mark --- DWCheckBoxManager ---
@interface DWCheckBoxManager ()
@property (nonatomic ,strong) NSMutableArray <NSNumber *>* selectedArr;
@property (nonatomic ,assign) NSUInteger lastSelected;
@end
@implementation DWCheckBoxManager
-(instancetype)initWithCountOfBoxes:(NSUInteger)countOfBoxes multiSelect:(BOOL)multiSelect defaultSelect:(NSArray <NSNumber *>*)defaultSelect selectedChangeBlock:(void (^)(DWCheckBoxManager *,id,NSString *))selechtChangeBlock
{
self = [super init];
if (self) {
_countOfBoxes = countOfBoxes;
_multiSelect = multiSelect;
if (defaultSelect.count) {
[defaultSelect enumerateObjectsUsingBlock:^(NSNumber * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
[self selectAtIndex:obj.unsignedIntegerValue];
}];
}
if (selechtChangeBlock) {
self.selectedChangeBlock = selechtChangeBlock;
}
}
return self;
}
-(void)selectAtIndex:(NSUInteger)idx
{
if (idx < self.countOfBoxes) {
if (self.multiSelect) {///多选操作
if ((![self.selectedArr containsObject:@(idx)]) && (self.selectedArr.count < self.countOfBoxes)) {
[self.selectedArr addObject:@(idx)];
__Select__Block__
}
} else {///单选操作
if (self.selectedArr.count) {
[self.selectedArr removeAllObjects];
}
[self.selectedArr addObject:@(idx)];
__Select__Block__
}
}
}
-(void)deselectAtIndex:(NSUInteger)idx
{
if (idx < self.countOfBoxes) {
if ([self.selectedArr containsObject:@(idx)]) {
[self.selectedArr removeObject:@(idx)];
__Select__Block__
}
}
}
-(void)deselectAll
{
[self.selectedArr removeAllObjects];
__Select__Block__
}
-(void)selectAll
{
if (self.multiSelect) {
if (self.selectedArr.count != self.countOfBoxes) {
[self.selectedArr removeAllObjects];
for (int i = 0; i < self.countOfBoxes; i++) {
[self.selectedArr addObject:@(i)];
}
__Select__Block__
}
} else {
if (!self.selectedArr.count) {
[self.selectedArr addObject:@(1)];
__Select__Block__
}
}
}
-(id)currentSelected
{
if (self.multiSelect) {
return [self.selectedArr sortedArrayUsingSelector:@selector(compare:)];
} else {
if (self.selectedArr.count) {
return self.selectedArr.firstObject;
}
return nil;
}
}
-(NSMutableArray<NSNumber *> *)selectedArr
{
if (!_selectedArr) {
_selectedArr = [NSMutableArray array];
}
return _selectedArr;
}
-(void)setMultiSelect:(BOOL)multiSelect
{
_multiSelect = multiSelect;
if (!multiSelect && self.selectedArr.count > 1) {
NSNumber * lastSelected = self.selectedArr.lastObject;
[self.selectedArr removeAllObjects];
[self.selectedArr addObject:lastSelected];
}
__Select__Block__
}
-(void)setCountOfBoxes:(NSUInteger)countOfBoxes
{
_countOfBoxes = countOfBoxes;
if (countOfBoxes < self.selectedArr.count) {
NSMutableArray * arr = [NSMutableArray array];
for (int i = 0; i < countOfBoxes; i++) {
[arr addObject:self.selectedArr[i]];
}
self.selectedArr = arr;
__Select__Block__
}
}
-(NSString *)identifier
{
if (!_identifier) {
return @"defaultCheckBox";
}
return _identifier;
}
-(UIImage *)selectedImage
{
if (!_selectedImage) {
return [UIImage imageNamed:[NSString stringWithFormat:@"DWCheckBoxBundle.bundle/%@",self.multiSelect?@"checkBoxSelected":@"radioSelected"]];
}
return _selectedImage;
}
-(UIImage *)unSelectedImage
{
if (!_unSelectedImage) {
return [UIImage imageNamed:[NSString stringWithFormat:@"DWCheckBoxBundle.bundle/%@",self.multiSelect?@"checkBoxUnselected":@"radioUnselected"]];
}
return _unSelectedImage;
}
@end
| {'content_hash': 'a625a6e97f891c678cd2e5eb78fb0e8d', 'timestamp': '', 'source': 'github', 'line_count': 496, 'max_line_length': 233, 'avg_line_length': 29.31048387096774, 'alnum_prop': 0.6543541064795708, 'repo_name': 'CodeWicky/DWCheckBox', 'id': '546e8262e39ab0bdeda332ba526077eedaab1086', 'size': '14742', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'DWCheckBox/DWCheckBox.m', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Objective-C', 'bytes': '91214'}, {'name': 'Ruby', 'bytes': '646'}]} |
var FormComponents = function () {
var handleWysihtml5 = function () {
if (!jQuery().wysihtml5) {
return;
}
if ($('.wysihtml5').size() > 0) {
$('.wysihtml5').wysihtml5({
"stylesheets": ["assets/plugins/bootstrap-wysihtml5/wysiwyg-color.css"]
});
}
}
var resetWysihtml5 = function () {
if (!jQuery().wysihtml5) {
return;
}
if ($('.wysihtml5').size() > 0) {
$('.wysihtml5').wysihtml5({
"stylesheets": ["assets/plugins/bootstrap-wysihtml5/wysiwyg-color.css"]
});
}
}
var handleToggleButtons = function () {
if (!jQuery().toggleButtons) {
return;
}
$('.basic-toggle-button').toggleButtons();
$('.text-toggle-button').toggleButtons({
width: 200,
label: {
enabled: "Lorem Ipsum",
disabled: "Dolor Sit"
}
});
$('.danger-toggle-button').toggleButtons({
style: {
// Accepted values ["primary", "danger", "info", "success", "warning"] or nothing
enabled: "danger",
disabled: "info"
}
});
$('.info-toggle-button').toggleButtons({
style: {
enabled: "info",
disabled: ""
}
});
$('.success-toggle-button').toggleButtons({
style: {
enabled: "success",
disabled: "info"
}
});
$('.warning-toggle-button').toggleButtons({
style: {
enabled: "warning",
disabled: "info"
}
});
$('.height-toggle-button').toggleButtons({
height: 100,
font: {
'line-height': '100px',
'font-size': '20px',
'font-style': 'italic'
}
});
}
var handleTagsInput = function () {
if (!jQuery().tagsInput) {
return;
}
$('#tags_1').tagsInput({
width: 'auto',
'onAddTag': function () {
//alert(1);
},
});
$('#tags_2').tagsInput({
width: 240
});
}
var handlejQueryUIDatePickers = function () {
$( ".ui-date-picker" ).datepicker();
}
var handleDatePickers = function () {
if (jQuery().datepicker) {
$('.date-picker').datepicker({
rtl : App.isRTL()
});
}
}
var handleTimePickers = function () {
if (jQuery().timepicker) {
$('.timepicker-default').timepicker();
$('.timepicker-24').timepicker({
minuteStep: 1,
showSeconds: true,
showMeridian: false
});
}
}
var handleDateRangePickers = function () {
if (!jQuery().daterangepicker) {
return;
}
$('.date-range').daterangepicker(
{
opens: (App.isRTL() ? 'left' : 'right'),
format: 'MM/dd/yyyy',
separator: ' to ',
startDate: Date.today().add({
days: -29
}),
endDate: Date.today(),
minDate: '01/01/2012',
maxDate: '12/31/2014',
}
);
$('#form-date-range').daterangepicker({
ranges: {
'Today': ['today', 'today'],
'Yesterday': ['yesterday', 'yesterday'],
'Last 7 Days': [Date.today().add({
days: -6
}), 'today'],
'Last 29 Days': [Date.today().add({
days: -29
}), 'today'],
'This Month': [Date.today().moveToFirstDayOfMonth(), Date.today().moveToLastDayOfMonth()],
'Last Month': [Date.today().moveToFirstDayOfMonth().add({
months: -1
}), Date.today().moveToFirstDayOfMonth().add({
days: -1
})]
},
opens: (App.isRTL() ? 'left' : 'right'),
format: 'MM/dd/yyyy',
separator: ' to ',
startDate: Date.today().add({
days: -29
}),
endDate: Date.today(),
minDate: '01/01/2012',
maxDate: '12/31/2014',
locale: {
applyLabel: 'Submit',
fromLabel: 'From',
toLabel: 'To',
customRangeLabel: 'Custom Range',
daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
firstDay: 1
},
showWeekNumbers: true,
buttonClasses: ['btn-danger']
},
function (start, end) {
$('#form-date-range span').html(start.toString('MMMM d, yyyy') + ' - ' + end.toString('MMMM d, yyyy'));
});
$('#form-date-range span').html(Date.today().add({
days: -29
}).toString('MMMM d, yyyy') + ' - ' + Date.today().toString('MMMM d, yyyy'));
//modal version:
$('#form-date-range-modal').daterangepicker({
ranges: {
'Today': ['today', 'today'],
'Yesterday': ['yesterday', 'yesterday'],
'Last 7 Days': [Date.today().add({
days: -6
}), 'today'],
'Last 29 Days': [Date.today().add({
days: -29
}), 'today'],
'This Month': [Date.today().moveToFirstDayOfMonth(), Date.today().moveToLastDayOfMonth()],
'Last Month': [Date.today().moveToFirstDayOfMonth().add({
months: -1
}), Date.today().moveToFirstDayOfMonth().add({
days: -1
})]
},
opens: (App.isRTL() ? 'left' : 'right'),
format: 'MM/dd/yyyy',
separator: ' to ',
startDate: Date.today().add({
days: -29
}),
endDate: Date.today(),
minDate: '01/01/2012',
maxDate: '12/31/2014',
locale: {
applyLabel: 'Submit',
fromLabel: 'From',
toLabel: 'To',
customRangeLabel: 'Custom Range',
daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
firstDay: 1
},
showWeekNumbers: true,
buttonClasses: ['btn-danger']
},
function (start, end) {
$('#form-date-range-modal span').html(start.toString('MMMM d, yyyy') + ' - ' + end.toString('MMMM d, yyyy'));
});
$('#form-date-range-modal span').html(Date.today().add({
days: -29
}).toString('MMMM d, yyyy') + ' - ' + Date.today().toString('MMMM d, yyyy'));
}
var handleDatetimePicker = function () {
$(".form_datetime").datetimepicker({
format: "dd MM yyyy - hh:ii",
pickerPosition: (App.isRTL() ? "bottom-right" : "bottom-left")
});
$(".form_advance_datetime").datetimepicker({
format: "dd MM yyyy - hh:ii",
autoclose: true,
todayBtn: true,
startDate: "2013-02-14 10:00",
pickerPosition: (App.isRTL() ? "bottom-right" : "bottom-left"),
minuteStep: 10
});
$(".form_meridian_datetime").datetimepicker({
format: "dd MM yyyy - HH:ii P",
showMeridian: true,
autoclose: true,
pickerPosition: (App.isRTL() ? "bottom-right" : "bottom-left"),
todayBtn: true
});
}
var handleClockfaceTimePickers = function () {
if (!jQuery().clockface) {
return;
}
$('.clockface_1').clockface();
$('#clockface_2').clockface({
format: 'HH:mm',
trigger: 'manual'
});
$('#clockface_2_toggle').click(function (e) {
e.stopPropagation();
$('#clockface_2').clockface('toggle');
});
$('#clockface_2_modal').clockface({
format: 'HH:mm',
trigger: 'manual'
});
$('#clockface_2_modal_toggle').click(function (e) {
e.stopPropagation();
$('#clockface_2_modal').clockface('toggle');
});
$('.clockface_3').clockface({
format: 'H:mm'
}).clockface('show', '14:30');
}
var handleColorPicker = function () {
if (!jQuery().colorpicker) {
return;
}
$('.colorpicker-default').colorpicker({
format: 'hex'
});
$('.colorpicker-rgba').colorpicker();
}
var handleSelec2 = function () {
$('#select2_sample1').select2({
placeholder: "Select an option",
allowClear: true
});
$('#select2_sample2').select2({
placeholder: "Select a State",
allowClear: true
});
$("#select2_sample3").select2({
allowClear: true,
minimumInputLength: 1,
query: function (query) {
var data = {
results: []
}, i, j, s;
for (i = 1; i < 5; i++) {
s = "";
for (j = 0; j < i; j++) {
s = s + query.term;
}
data.results.push({
id: query.term + i,
text: s
});
}
query.callback(data);
}
});
function format(state) {
if (!state.id) return state.text; // optgroup
return "<img class='flag' src='assets/img/flags/" + state.id.toLowerCase() + ".png'/> " + state.text;
}
$("#select2_sample4").select2({
allowClear: true,
formatResult: format,
formatSelection: format,
escapeMarkup: function (m) {
return m;
}
});
$("#select2_sample5").select2({
tags: ["red", "green", "blue", "yellow", "pink"]
});
function movieFormatResult(movie) {
var markup = "<table class='movie-result'><tr>";
if (movie.posters !== undefined && movie.posters.thumbnail !== undefined) {
markup += "<td valign='top'><img src='" + movie.posters.thumbnail + "'/></td>";
}
markup += "<td valign='top'><h5>" + movie.title + "</h5>";
if (movie.critics_consensus !== undefined) {
markup += "<div class='movie-synopsis'>" + movie.critics_consensus + "</div>";
} else if (movie.synopsis !== undefined) {
markup += "<div class='movie-synopsis'>" + movie.synopsis + "</div>";
}
markup += "</td></tr></table>"
return markup;
}
function movieFormatSelection(movie) {
return movie.title;
}
$("#select2_sample6").select2({
placeholder: "Search for a movie",
minimumInputLength: 1,
ajax: { // instead of writing the function to execute the request we use Select2's convenient helper
url: "http://api.rottentomatoes.com/api/public/v1.0/movies.json",
dataType: 'jsonp',
data: function (term, page) {
return {
q: term, // search term
page_limit: 10,
apikey: "ju6z9mjyajq2djue3gbvv26t" // please do not use so this example keeps working
};
},
results: function (data, page) { // parse the results into the format expected by Select2.
// since we are using custom formatting functions we do not need to alter remote JSON data
return {
results: data.movies
};
}
},
initSelection: function (element, callback) {
// the input tag has a value attribute preloaded that points to a preselected movie's id
// this function resolves that id attribute to an object that select2 can render
// using its formatResult renderer - that way the movie name is shown preselected
var id = $(element).val();
if (id !== "") {
$.ajax("http://api.rottentomatoes.com/api/public/v1.0/movies/" + id + ".json", {
data: {
apikey: "ju6z9mjyajq2djue3gbvv26t"
},
dataType: "jsonp"
}).done(function (data) {
callback(data);
});
}
},
formatResult: movieFormatResult, // omitted for brevity, see the source of this page
formatSelection: movieFormatSelection, // omitted for brevity, see the source of this page
dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
escapeMarkup: function (m) {
return m;
} // we do not want to escape markup since we are displaying html in results
});
}
var handleMultiSelect = function () {
$('#my_multi_select1').multiSelect();
$('#my_multi_select2').multiSelect({
selectableOptgroup: true
});
}
var handleInputMasks = function () {
$.extend($.inputmask.defaults, {
'autounmask': true
});
$("#mask_date").inputmask("d/m/y", {autoUnmask: true}); //direct mask
$("#mask_date1").inputmask("d/m/y",{ "placeholder": "*"}); //change the placeholder
$("#mask_date2").inputmask("d/m/y",{ "placeholder": "dd/mm/yyyy" }); //multi-char placeholder
$("#mask_phone").inputmask("mask", {"mask": "(999) 999-9999"}); //specifying fn & options
$("#mask_tin").inputmask({"mask": "99-9999999"}); //specifying options only
$("#mask_number").inputmask({ "mask": "9", "repeat": 10, "greedy": false }); // ~ mask "9" or mask "99" or ... mask "9999999999"
$("#mask_decimal").inputmask('decimal', { rightAlignNumerics: false }); //disables the right alignment of the decimal input
$("#mask_currency").inputmask('€ 999.999.999,99', { numericInput: true }); //123456 => € ___.__1.234,56
$("#mask_currency2").inputmask('€ 999,999,999.99', { numericInput: true, rightAlignNumerics: false, greedy: false}); //123456 => € ___.__1.234,56
$("#mask_ssn").inputmask("999-99-9999", {placeholder:" ", clearMaskOnLostFocus: true }); //default
}
var handleIPAddressInput = function () {
$('#input_ipv4').ipAddress();
$('#input_ipv6').ipAddress({v:6});
}
return {
//main function to initiate the module
init: function () {
handleWysihtml5();
handleToggleButtons();
handleTagsInput();
handlejQueryUIDatePickers();
handleDatePickers();
handleTimePickers();
handleDatetimePicker();
handleDateRangePickers();
handleClockfaceTimePickers();
handleColorPicker();
handleSelec2();
handleInputMasks();
handleIPAddressInput();
handleMultiSelect();
App.addResponsiveHandler(function(){
resetWysihtml5();
})
}
};
}(); | {'content_hash': '02f6f79515271ed22f6b8052821eb660', 'timestamp': '', 'source': 'github', 'line_count': 471, 'max_line_length': 155, 'avg_line_length': 34.54352441613588, 'alnum_prop': 0.45230485556238476, 'repo_name': 'Sparring/sparring-v1.0-beta', 'id': 'ea29a1dc9497314bb49f157f9d838a867253f892', 'size': '16278', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'assets/scripts/form-components.js', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'CSS', 'bytes': '822740'}, {'name': 'CoffeeScript', 'bytes': '57172'}, {'name': 'Go', 'bytes': '6713'}, {'name': 'JavaScript', 'bytes': '3199127'}, {'name': 'PHP', 'bytes': '1674408'}, {'name': 'Python', 'bytes': '5173'}, {'name': 'Ruby', 'bytes': '861'}, {'name': 'Shell', 'bytes': '2037'}]} |
<?php
declare(strict_types=1); // @codeCoverageIgnore
namespace Recoil;
/**
* A strand trace is a low-level observer of strand events.
*
* @see Strand::setTrace()
*
* A trace may only be set on a strand when assertions are enabled. When
* assertions are disabled, all tracing related code is disabled, and setting
* a trace has no effect.
*
* If an exception is thrown from any of the StrandTrace methods the kernel
* behaviour is undefined.
*
* @link http://php.net/manual/en/ini.core.php#ini.zend.assertions
*/
interface StrandTrace
{
/**
* Record a push to the call-stack.
*
* @param Strand $strand The strand being traced.
* @param int $depth The depth of the call-stack BEFORE the push operation.
*
* @return null
*/
public function push(Strand $strand, int $depth);
/**
* Record a pop from the call-stack.
*
* @param Strand $strand The strand being traced.
* @param int $depth The depth of the call-stack AFTER the pop operation.
*
* @return null
*/
public function pop(Strand $strand, int $depth);
/**
* Record keys and values yielded from the coroutine on the head of the stack.
*
* @param Strand $strand The strand being traced.
* @param int $depth The current depth of the call-stack.
* @param mixed $key The key yielded from the coroutine.
* @param mixed $value The value yielded from the coroutine.
*
* @return null
*/
public function yield(Strand $strand, int $depth, $key, $value);
/**
* Record the action and value used to resume a yielded coroutine.
*
* @param Strand $strand The strand being traced.
* @param int $depth The current depth of the call-stack.
* @param string $action The resume action ('send' or 'throw').
* @param mixed $value The resume value or exception.
*
* @return null
*/
public function resume(Strand $strand, int $depth, string $action, $value);
/**
* Record the suspension of a strand.
*
* @param Strand $strand The strand being traced.
* @param int $depth The current depth of the call-stack.
*
* @return null
*/
public function suspend(Strand $strand, int $depth);
/**
* Record the action and value when a strand exits.
*
* @param Strand $strand The strand being traced.
* @param int $depth The current depth of the call-stack.
* @param string $action The final action performed on the strand's listener ('send' or 'throw').
* @param mixed $value The strand result or exception.
*
* @return null
*/
public function exit(Strand $strand, int $depth, string $action, $value);
}
| {'content_hash': 'e6dfebd9489e1eaa8b4ec9eed350dba1', 'timestamp': '', 'source': 'github', 'line_count': 88, 'max_line_length': 101, 'avg_line_length': 31.375, 'alnum_prop': 0.6341905106845346, 'repo_name': 'recoilphp/api', 'id': 'c5a9393bd3a86144fcaf2307da5ff699c91e0a02', 'size': '2761', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/StrandTrace.php', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Makefile', 'bytes': '144'}, {'name': 'PHP', 'bytes': '49121'}]} |
namespace dawn_native { namespace null {
using BindGroup = BindGroupBase;
using BindGroupLayout = BindGroupLayoutBase;
using BlendState = BlendStateBase;
class Buffer;
using BufferView = BufferViewBase;
class CommandBuffer;
using ComputePipeline = ComputePipelineBase;
using DepthStencilState = DepthStencilStateBase;
class Device;
using InputState = InputStateBase;
using PipelineLayout = PipelineLayoutBase;
class Queue;
using RenderPassDescriptor = RenderPassDescriptorBase;
using RenderPipeline = RenderPipelineBase;
using Sampler = SamplerBase;
using ShaderModule = ShaderModuleBase;
class SwapChain;
using Texture = TextureBase;
using TextureView = TextureViewBase;
struct NullBackendTraits {
using BindGroupType = BindGroup;
using BindGroupLayoutType = BindGroupLayout;
using BlendStateType = BlendState;
using BufferType = Buffer;
using BufferViewType = BufferView;
using CommandBufferType = CommandBuffer;
using ComputePipelineType = ComputePipeline;
using DepthStencilStateType = DepthStencilState;
using DeviceType = Device;
using InputStateType = InputState;
using PipelineLayoutType = PipelineLayout;
using QueueType = Queue;
using RenderPassDescriptorType = RenderPassDescriptor;
using RenderPipelineType = RenderPipeline;
using SamplerType = Sampler;
using ShaderModuleType = ShaderModule;
using SwapChainType = SwapChain;
using TextureType = Texture;
using TextureViewType = TextureView;
};
template <typename T>
auto ToBackend(T&& common) -> decltype(ToBackendBase<NullBackendTraits>(common)) {
return ToBackendBase<NullBackendTraits>(common);
}
struct PendingOperation {
virtual ~PendingOperation() = default;
virtual void Execute() = 0;
};
class Device : public DeviceBase {
public:
Device();
~Device();
BindGroupBase* CreateBindGroup(BindGroupBuilder* builder) override;
BlendStateBase* CreateBlendState(BlendStateBuilder* builder) override;
BufferViewBase* CreateBufferView(BufferViewBuilder* builder) override;
CommandBufferBase* CreateCommandBuffer(CommandBufferBuilder* builder) override;
DepthStencilStateBase* CreateDepthStencilState(DepthStencilStateBuilder* builder) override;
InputStateBase* CreateInputState(InputStateBuilder* builder) override;
RenderPassDescriptorBase* CreateRenderPassDescriptor(
RenderPassDescriptorBuilder* builder) override;
RenderPipelineBase* CreateRenderPipeline(RenderPipelineBuilder* builder) override;
SwapChainBase* CreateSwapChain(SwapChainBuilder* builder) override;
TextureViewBase* CreateTextureView(TextureViewBuilder* builder) override;
void TickImpl() override;
void AddPendingOperation(std::unique_ptr<PendingOperation> operation);
std::vector<std::unique_ptr<PendingOperation>> AcquirePendingOperations();
private:
ResultOrError<BindGroupLayoutBase*> CreateBindGroupLayoutImpl(
const BindGroupLayoutDescriptor* descriptor) override;
ResultOrError<BufferBase*> CreateBufferImpl(const BufferDescriptor* descriptor) override;
ResultOrError<ComputePipelineBase*> CreateComputePipelineImpl(
const ComputePipelineDescriptor* descriptor) override;
ResultOrError<PipelineLayoutBase*> CreatePipelineLayoutImpl(
const PipelineLayoutDescriptor* descriptor) override;
ResultOrError<QueueBase*> CreateQueueImpl() override;
ResultOrError<SamplerBase*> CreateSamplerImpl(const SamplerDescriptor* descriptor) override;
ResultOrError<ShaderModuleBase*> CreateShaderModuleImpl(
const ShaderModuleDescriptor* descriptor) override;
ResultOrError<TextureBase*> CreateTextureImpl(const TextureDescriptor* descriptor) override;
std::vector<std::unique_ptr<PendingOperation>> mPendingOperations;
};
class Buffer : public BufferBase {
public:
Buffer(Device* device, const BufferDescriptor* descriptor);
~Buffer();
void MapReadOperationCompleted(uint32_t serial, void* ptr, bool isWrite);
private:
void SetSubDataImpl(uint32_t start, uint32_t count, const uint8_t* data) override;
void MapReadAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) override;
void MapWriteAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) override;
void UnmapImpl() override;
void MapAsyncImplCommon(uint32_t serial, uint32_t start, uint32_t count, bool isWrite);
std::unique_ptr<char[]> mBackingData;
};
class CommandBuffer : public CommandBufferBase {
public:
CommandBuffer(CommandBufferBuilder* builder);
~CommandBuffer();
private:
CommandIterator mCommands;
};
class Queue : public QueueBase {
public:
Queue(Device* device);
~Queue();
private:
void SubmitImpl(uint32_t numCommands, CommandBufferBase* const* commands) override;
};
class SwapChain : public SwapChainBase {
public:
SwapChain(SwapChainBuilder* builder);
~SwapChain();
protected:
TextureBase* GetNextTextureImpl(const TextureDescriptor* descriptor) override;
void OnBeforePresent(TextureBase*) override;
};
}} // namespace dawn_native::null
#endif // DAWNNATIVE_NULL_NULLBACKEND_H_
| {'content_hash': 'b49971bb8e0f23809fbb333ff7698e73', 'timestamp': '', 'source': 'github', 'line_count': 142, 'max_line_length': 100, 'avg_line_length': 39.40845070422535, 'alnum_prop': 0.711758398856326, 'repo_name': 'googlearchive/nxt-standalone', 'id': '1a348142225cee4116bd80566e1b7d8da7ba62dd', 'size': '6976', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/dawn_native/null/NullBackend.h', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'C', 'bytes': '11485'}, {'name': 'C++', 'bytes': '1466911'}, {'name': 'CMake', 'bytes': '37339'}, {'name': 'Objective-C', 'bytes': '21701'}, {'name': 'Objective-C++', 'bytes': '83113'}, {'name': 'Python', 'bytes': '47104'}, {'name': 'Shell', 'bytes': '2503'}]} |
<footer class="content-info" role="contentinfo">
<div class="footerCallToAction">
<div class="container ctaText">
<h2>A great community awaits.</h2>
<h3><a>Join</a></h3>
</div>
</div>
<div class="mainFooter">
<div class="container">
<a class="footerLogo tk-sarina" href="join"><img src="<?php echo get_template_directory_uri();; ?>/assets/img/logoespacio.png"></a>
<nav class="collapse navbar-collapse" role="navigation">
<?php
if (has_nav_menu('primary_navigation')) :
wp_nav_menu(array('theme_location' => 'primary_navigation', 'menu_class' => 'nav navbar-nav'));
endif;
?>
</nav>
</div>
</div>
</footer>
<?php wp_footer(); ?> | {'content_hash': 'd057ddd3f79efdbb98dd386e1a854dfd', 'timestamp': '', 'source': 'github', 'line_count': 24, 'max_line_length': 135, 'avg_line_length': 30.041666666666668, 'alnum_prop': 0.5922330097087378, 'repo_name': 'heyellieday/coffeeoforigin', 'id': 'fd17da60860fbcc5a5e0ca21183ba7492231cf37', 'size': '721', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'templates/footer.php', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '214391'}, {'name': 'JavaScript', 'bytes': '7554'}, {'name': 'PHP', 'bytes': '57095'}]} |
import sys
import os
import re
import subprocess as sp
try:
from .version import __version__
except ImportError:
__version__ = 'unknown'
def indent_level(line):
"""Get the indent level for a line of mkvinfo output.
Returns -1 if *line* is not the correct format."""
m = re.search(r'^\|( *)\+', line)
if not m:
return -1
return len(m.group(1))
class TrackLineHandler:
'Parse a line of (English) mkvinfo output inside "A track".'
_number = '| + Track number: '
_type = '| + Track type: '
_codec = '| + Codec ID: '
_lang = '| + Language: '
_duration = '| + Default duration: '
fps = r'\((.*?) frames/fields per second for a video track\)'
_fps_re = re.compile(fps)
def __init__(self, infodict):
self._info = infodict
def _findvalue(self, key, s):
idx = s.find(key)
if idx != -1:
return s[idx + len(key):]
return None
def line(self, handlers, l):
self._track = self._info['tracks'][-1]
cls = TrackLineHandler
ind = indent_level(l)
if ind == -1 or ind < 2:
handlers.pop(-1)
return False
number = self._findvalue(cls._number, l)
if number:
endidx = number.find(' ')
if endidx == -1:
number = int(number)
else:
number = int(number[:endidx])
self._track['number'] = number - 1
return True
typ = self._findvalue(cls._type, l)
if typ:
self._track['type'] = typ
return True
codec = self._findvalue(cls._codec, l)
if codec:
if codec[0] in ('V', 'A', 'S') and len(codec) > 1 and codec[1] == '_':
codec = codec[2:]
self._track['codec'] = codec
return True
lang = self._findvalue(cls._lang, l)
if lang:
self._track['language'] = lang
return True
if self._track.get('type', '') == 'video':
duration = self._findvalue(cls._duration, l)
if duration:
match = cls._fps_re.search(l)
if match:
self._track['fps'] = float(match.group(1))
return True
return True
class MainLineHandler:
"Parse a line of (locale='en_US') mkvinfo output."
def __init__(self, infodict):
self._info = infodict
self._track = TrackLineHandler(infodict)
def line(self, handlers, l):
if l.startswith('|+ Segment tracks'):
self._info.setdefault('tracks', [])
return True
elif l.startswith('| + Track'):
self._info.setdefault('tracks', [])
self._info['tracks'].append({})
handlers.append(self._track)
return True
return True
def info_locale_opts(locale):
"""Example usage with *infostring*::
opts = info_locale_opts('en_US')
opts.setdefault('arguments', [])
opts['arguments'].extend(['-x', '-r', 'mkvinfo.log'])
opts.setdefault('env', {})
opts['env']['MTX_DEBUG'] = 'topic'
print infostring(mkv, **opts)
"""
return {'arguments': ['--ui-language', locale]}
def infostring(mkv, env=None, arguments=[], errorfunc=sys.exit, mkvinfo=None):
"""Run mkvinfo on the given *mkv* and returns stdout as a single string.
On failure, calls *errorfunc* with an error string.
It's likely you'll want to set *env* or *arguments* to use ``'en_US'``
locale, since that is what *infodict* requires. See
*info_locale_opts*.
"""
if not mkvinfo:
mkvinfo = 'mkvinfo'
cmd = [mkvinfo] + arguments + [mkv]
opts = {}
if env is not None:
env.setdefault('PATH', os.environ.get('PATH', ''))
env.setdefault('SystemRoot', os.environ.get('SystemRoot', ''))
opts = {'env': env}
proc = sp.Popen(
cmd, stdout=sp.PIPE, stderr=sp.PIPE, close_fds=True, **opts
)
out, err = proc.communicate()
if proc.returncode != 0:
if err is not str:
err = err.decode('utf_8')
errorfunc('command failed: ' + err.rstrip('\n'))
if out is not str:
out = out.decode('utf_8')
return out
def infodict(lines):
"""Take a list of *lines* of ``locale='en_US'`` mkvinfo output and return a
dictionary of info."""
infod = {'lines': lines}
handlers = [MainLineHandler(infod)]
for l in lines:
while not handlers[-1].line(handlers, l):
if not handlers:
break
if not handlers:
break
return infod
if __name__ == '__main__':
from pprint import pprint
mkv = sys.argv[1]
s = infostring(mkv, arguments=['--ui-language', 'en_US'])
d = infodict(s.rstrip('\n').split('\n'))
del d['lines']
pprint(d)
| {'content_hash': '450fa672ecf9e05263faadb724bc43e5', 'timestamp': '', 'source': 'github', 'line_count': 161, 'max_line_length': 82, 'avg_line_length': 30.26086956521739, 'alnum_prop': 0.5344827586206896, 'repo_name': 'gavinbeatty/mkvtomp4', 'id': '41b4bcc8aa676cc4c6d7117e92c7f7a10fa3b9df', 'size': '4872', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'simplemkv/info.py', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Makefile', 'bytes': '1767'}, {'name': 'Python', 'bytes': '36515'}]} |
> ## Note: Yosemite (and later)
>
> Starting in Yosemite (10.10), the wrapper program does not seem to
> be needed for pasteboard access. It may still be useful for some
> [other services][other], however.
[other]: #beyond-pasteboard-access
The basic configuration is to set *tmux*’s `default-command` so that
your interactive shell ends up reattached to the user bootstrap
namespace:
set-option -g default-command 'reattach-to-user-namespace -l zsh'
Since the “attachment status” is inherited by child processes, this
configuration will ensure that all the commands started from your
shell will also be properly attached.
# Configuration Alternatives
## Cross-Platform Conditional Usage
Some users like to share identical configuration files (including
`.tmux.conf`) with systems where the wrapper program is not
available (e.g. same files on both OS X and Linux). Starting with
*tmux* 1.9, it is safe to use `if-shell` to conditionally configure
the use of the wrapper program:
if-shell 'test "$(uname -s)" = Darwin' 'set-option -g default-command "exec reattach-to-user-namespace -l zsh"'
Or, if you have other platform specific configuration, you can
conditionally source another file.
In `.tmux.conf`:
if-shell 'test "$(uname -s)" = Darwin' 'source-file ~/.tmux-osx.conf'
Then in `.tmux-osx.conf`, include the `default-command` setting and
any other bits of OS X configuration (e.g. the buffer-to-pasteboard
bindings shown below):
set-option -g default-command 'exec reattach-to-user-namespace -l zsh'
With *tmux* 1.8 and earlier, the above configuration has a race
condition (the `if-shell` command is run in the background) and/or
does not affect the initial session/window/pane. Instead, the basic
`default-command` can be extended with a bit of shell code to
conditionally use the wrapper only where it is present:
set-option -g default-command 'command -v reattach-to-user-namespace >/dev/null && exec reattach-to-user-namespace -l "$SHELL" || exec "$SHELL"'
The `default-command` will be run using your `default-shell` (which
defaults to SHELL, your login shell, or `/bin/sh`). This particular
code should work on most systems, but it may fail if the effective
shell is not POSIX compliant (old-style `/bin/sh`, a *csh* variant,
*fish*, etc.). If one of your systems does not understand `command
-v` (or if it does something unrelated that returns the wrong exit
value), then you might try using `which` instead. Exotic shells may
also require different syntax.
## Fine-Grained Usage
Instead of using `default-command` to “wrap” your top-level shells,
you can instead use the wrapper on just the tools that need it (see
“Beyond Pasteboard Access” (below) for other commands that may also
need the wrapper).
You might want to adopt this approach if part of your shell
initialization takes a long time to run: the `default-command` will
start your shell twice (once to process the `default-command`, and
once more for the final, interactive shell that is started by the
`default-command`). For example if your SHELL is *zsh*, then your
`.zshenv` (if you have one) will be run twice (the other
initialization files will only be run once).
For example, you could leave your shell “detached” and run
`reattach-to-user-namespace pbpaste` to read from the pasteboard. If
you take this approach, you may want to use a small script, shell
alias, or shell function to supply a shorter name for the wrapper
program (or wrap the individual commands—the
`reattach-to-user-namespace` *Homebrew* recipe has some support for
this).
You will also need to apply this fine-grained “wrapping” if you want
to have *tmux* directly run commands that need to be reattached.
For example, you might use bindings like the following to write
a *tmux* buffer to the OS X pasteboard or to paste the OS X
pasteboard into the current *tmux* pane.
bind-key C-c run-shell 'tmux save-buffer - | reattach-to-user-namespace pbcopy'
bind-key C-v run-shell 'reattach-to-user-namespace pbpaste | tmux load-buffer - \; paste-buffer -d'
Similarly, for the `copy-pipe` command (new in *tmux* 1.8):
bind-key -t vi-copy y copy-pipe 'reattach-to-user-namespace pbcopy'
bind-key -t emacs-copy M-w copy-pipe 'reattach-to-user-namespace pbcopy'
# Beyond Pasteboard Access
Because the fix applied by the wrapper program is not limited to
just pasteboard access, there are other bugs/issues/problems that
come up when running under *tmux* that the wrapper can help
alleviate.
* `nohup`
The *nohup* program aborts if it cannot “detach from console”.
Normally, processes running “inside” *tmux* (on the other side
of a daemon(3) call) are already detached; the wrapper
reattaches so that *nohup* can successfully detach itself.
*nohup* does generate an error message if it aborts due to
failing to detach, but it happens after the output has been
redirected so it ends up in the `nohup.out` file (or wherever
you sent stdout):
nohup: can't detach from console: Undefined error: 0
References: [problem using nohup within tmux on OSX 10.6][ml nohup]
[ml nohup]: http://thread.gmane.org/gmane.comp.terminal-emulators.tmux.user/4450
* The `export`, `getenv`, `setenv` subcommands of `launchctl`
Notably, the `setenv` subcommand will issue an error when it is
run from a “detached” context:
launch_msg("SetUserEnvironment"): Socket is not connected
The `getenv` and `export` commands will simply not have access
to some variables that have otherwise been configured in the
user’s *launchd* instance.
References: [tmux “Socket is not connected” error on OS X Lion][so setenv]
[so setenv]: http://stackoverflow.com/q/10193561/193688
* `subl -w` `subl --wait`
[su subl]: http://superuser.com/q/522055/14827
[so subl]: http://stackoverflow.com/q/13917095/193688
The *subl* command from *Sublime Text* can be used to open files
in the GUI window from a shell command line. The `-w` (or
`--wait`) option tells it to wait for the file to be closed in
the editor before exiting the `subl` command.
Whatever mechanism *Sublime Text* uses to coordinate between the
`subl` instance and the main *Sublime Text* instance is affected
by being “detached”. The result is that `subl -w` commands
issued inside *tmux* will not exit after the file is closed in
the GUI. The wrapper lets the `subl` command successfully
synchronize with the GUI instance.
References: ['subl -w' doesn't ever un-block when running under tmux on OS X][su subl] and [subl --wait doesn't work within tmux][so subl]
* Retina rendering of apps launched under *tmux* (10.9 Mavericks)
From feedback in [issue #22][issue 22]:
[issue 22]: https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard/issues/22
> Under Mavericks, applications launched from inside a tmux
> session cannot enable retina rendering (for reasons I don't
> understand -- this worked under Mountain Lion). If the shell
> inside the tmux session is reattached to the user namespace,
> then applications launched from the reattached shell do enable
> retina rendering when appropriate.
There may also be other contexts (aside from “inside *tmux*”) where
these same problems occur, but I have not yet heard of any.
| {'content_hash': '16092b79300745f7bcde44ecd3bd73c5', 'timestamp': '', 'source': 'github', 'line_count': 175, 'max_line_length': 148, 'avg_line_length': 41.88, 'alnum_prop': 0.7422567881020603, 'repo_name': 'bradparks/tmux-MacOSX-pasteboard', 'id': '4266845830d42f2147e0fb51fd11ff302dd5ea4f', 'size': '7402', 'binary': False, 'copies': '2', 'ref': 'refs/heads/master', 'path': 'Usage.md', 'mode': '33188', 'license': 'bsd-2-clause', 'language': [{'name': 'C', 'bytes': '22952'}, {'name': 'Makefile', 'bytes': '549'}]} |
$(function() {
if (!$('#signup-form').length) {
return false;
}
var signupValidationSettings = {
rules: {
firstname: {
required: true,
},
lastname: {
required: true,
},
email: {
required: true,
email: true
},
password: {
required: true,
minlength: 8
},
retype_password: {
required: true,
minlength: 8,
equalTo: "#password"
},
agree: {
required: true,
}
},
groups: {
name: "firstname lastname",
pass: "password retype_password",
},
errorPlacement: function(error, element) {
if (
element.attr("name") == "firstname" ||
element.attr("name") == "lastname"
) {
error.insertAfter($("#lastname").closest('.row'));
element.parents("div.form-group")
.addClass('has-error');
}
else if (
element.attr("name") == "password" ||
element.attr("name") == "retype_password"
) {
error.insertAfter($("#retype_password").closest('.row'));
element.parents("div.form-group")
.addClass('has-error');
}
else if (element.attr("name") == "agree") {
error.insertAfter("#agree-text");
}
else {
error.insertAfter(element);
}
},
messages: {
firstname: "Please enter firstname and lastname",
lastname: "Please enter firstname and lastname",
email: {
required: "Please enter email",
email: "Please enter a valid email address"
},
password: {
required: "Please enter password fields.",
minlength: "Passwords should be at least 8 characters."
},
retype_password: {
required: "Please enter password fields.",
minlength: "Passwords should be at least 8 characters."
},
agree: "Please accept our policy"
},
invalidHandler: function() {
animate({
name: 'shake',
selector: '.auth-container > .card'
});
}
}
$.extend(signupValidationSettings, config.validations);
$('#signup-form').validate(signupValidationSettings);
}); | {'content_hash': '657b85b39356dbbe94abb04263a12494', 'timestamp': '', 'source': 'github', 'line_count': 87, 'max_line_length': 65, 'avg_line_length': 24.54022988505747, 'alnum_prop': 0.5470725995316159, 'repo_name': 'Cheevil/Cheevil.github.io', 'id': 'c4468b73a7830e2b49bbd1305e37aa6cf8adfe54', 'size': '2159', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'src/auth/signup/signup.js', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '64035'}, {'name': 'HTML', 'bytes': '227786'}, {'name': 'JavaScript', 'bytes': '77924'}]} |
require File.dirname(__FILE__) + '/test_helper.rb'
require 'bot'
describe "TestBot" do
before(:each) do
@config = {
"server" => "server",
"port" => 6667,
"nick" => "nick",
"username" => "username",
"realname" => "realname",
"channels" => ["#first", "#second"],
"modules_dir" => "modules_dir",
"module_config" => {"some key" => "some value"}
}
@config_path = "path/to/config_file.yml"
expect(YAML).to receive(:load_file).with(@config_path).and_return(@config)
@module_handler = double()
expect(@module_handler).to receive(:reload)
end
context "Bot" do
before (:each) do
@bot = Bot.new(@config_path, @module_handler)
end
it "load nickname from config in initialization" do
expect(@bot.nick).to eq("nick")
end
it "give module specific configuration" do
expect(@bot.module_config).to eq(({"some key" => "some value"}))
end
it "add modules dir to $LOAD_PATH" do
expect($LOAD_PATH.include?("modules_dir")).to eq(true)
end
end
context "Disconnected Bot" do
before(:each) do
@connector = double()
@bot = Bot.new(@config_path, @module_handler)
expect(@bot).to receive(:create_connector).
with("server", 6667, "nick", "username", "realname", ["#first", "#second"]).
and_return(@connector)
end
it "connect" do
expect(@connector).to receive(:connect).and_return(nil)
@bot.connect
expect(@bot.connected).to eq(true)
end
it "raise exception" do
expect(@connector).to receive(:connect).and_throw(Exception)
expect { @bot.connect }.to raise_error(Exception)
end
it "attempt reconnection and then read input" do
expect(@connector).to receive(:connect)
expect(@connector).to receive(:read_input).and_return(IrcMsg.new(IrcMsg::NO_MSG))
@bot.handle_state
end
end
context "Connected Bot" do
before(:each) do
@connector = double()
@bot = Bot.new(@config_path, @module_handler)
expect(@bot).to receive(:create_connector).and_return(@connector)
expect(@connector).to receive(:connect)
@bot.connect
end
it "send raw msg" do
expect(@connector).to receive(:send).with("a raw message")
@bot.send_raw("a raw message")
end
it "send privmsg" do
expect(@connector).to receive(:privmsg).with("target", "message body")
@bot.send_privmsg("target", "message body")
end
it "disconnect when receiving disconnect message" do
expect(@connector).to receive(:read_input).and_return(IrcMsg.new(IrcMsg::DISCONNECTED))
@bot.handle_state
expect(@bot.connected).to eq(false)
end
it "print unhandled message" do
expect(@bot).to receive(:puts).with("<-- some unknown text").and_return(nil)
expect(@connector).to receive(:read_input).and_return(UnhandledMsg.new("some unknown text"))
@bot.handle_state
end
it "give handling of privmsg to module handler" do
msg = PrivMsg.new("from", "target", "text")
expect(@connector).to receive(:read_input).and_return(msg)
expect(@module_handler).to receive(:handle_privmsg).with("from", "target", "text")
@bot.handle_state
end
it "reload configuration on request" do
msg = PrivMsg.new("from", "target", "!reload")
expect(@connector).to receive(:read_input).and_return(msg)
expect(@bot).to receive(:reload_config)
@bot.handle_state
end
end
end
| {'content_hash': '5284d6d572b5906e63084f6df92e2ee9', 'timestamp': '', 'source': 'github', 'line_count': 111, 'max_line_length': 98, 'avg_line_length': 31.036036036036037, 'alnum_prop': 0.6339622641509434, 'repo_name': 'akisaarinen/lullizio', 'id': '9f459d19f66965570bd12b976f947b89f92c8581', 'size': '3472', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'spec/bot_spec.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Ruby', 'bytes': '48459'}, {'name': 'Shell', 'bytes': '130'}]} |
/*
* cg.h
*
* Created on: July 23, 2016
* Author: weitan
*/
#ifndef CG_H_
#define CG_H_
int updateXWithCG(const int batchSize, const int batchOffset, float * ythetaT, float * tt, float * XT,
cublasHandle_t handle, const int m, const int n, const int f, const int nnz);
void updateXWithCGHost(float * A, float * x, float * b, const int batchSize, const int f, const float cgIter);
void updateXWithCGHost_tt_fp16(float * A, float * x, float * b, const int batchSize, const int f, const float cgIter);
void alsUpdateFeature100Host(const int batch_offset,
const int* csrRowIndex, const int* csrColIndex, const float lambda, const int m, const int F,
const float* thetaT, float* XT, float* ythetaT, int cgIter);
#endif /* CG_H_ */
| {'content_hash': '7b1fd83c80d27c85edb87ee7d9dfac00', 'timestamp': '', 'source': 'github', 'line_count': 22, 'max_line_length': 118, 'avg_line_length': 34.13636363636363, 'alnum_prop': 0.6990679094540613, 'repo_name': 'wei-tan/CuMF', 'id': '538889b352e84d5b385c1b6713397e50b65fc1a8', 'size': '1551', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'cg.h', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'C', 'bytes': '43142'}, {'name': 'C++', 'bytes': '16557'}, {'name': 'Cuda', 'bytes': '220818'}, {'name': 'Jupyter Notebook', 'bytes': '3140'}, {'name': 'Makefile', 'bytes': '14741'}, {'name': 'Python', 'bytes': '8494'}, {'name': 'Shell', 'bytes': '2815'}]} |
class IcmpAttack < Package
after_initialize :initial_setting
before_save :initial_setting
private
def initial_setting
self.pre_configured_type = true
end
end | {'content_hash': '4ca42f69c1506613d6bd8745554e0874', 'timestamp': '', 'source': 'github', 'line_count': 8, 'max_line_length': 35, 'avg_line_length': 21.375, 'alnum_prop': 0.7602339181286549, 'repo_name': 'HoneyJack/FirewallTool', 'id': 'e9449b5caa3ae762daa6ff9d69cb1d114b18e783', 'size': '171', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'app/models/icmp_attack.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '19370'}, {'name': 'HTML', 'bytes': '76470'}, {'name': 'JavaScript', 'bytes': '1199515'}, {'name': 'Ruby', 'bytes': '147480'}]} |
package com.twitter.zipkin.json
import java.nio.ByteBuffer
import com.fasterxml.jackson.annotation.JsonProperty
import com.google.common.base.CaseFormat.{UPPER_CAMEL, UPPER_UNDERSCORE}
import com.google.common.io.BaseEncoding
import com.twitter.io.Charsets.Utf8
import com.twitter.zipkin.common._
import com.twitter.zipkin.common.AnnotationType._
case class JsonBinaryAnnotation(key: String,
value: Any,
@JsonProperty("type")
annotationType: Option[String],
endpoint: Option[JsonEndpoint])
object JsonBinaryAnnotation extends (BinaryAnnotation => JsonBinaryAnnotation) {
val base64 = BaseEncoding.base64()
val upperCamel = UPPER_UNDERSCORE.converterTo(UPPER_CAMEL)
def apply(b: BinaryAnnotation) = {
val (annotationType: Option[String], value: Any) = try {
b.annotationType.value match {
case Bool.value => (None, if (b.value.get(0) != 0) true else false)
case Bytes.value => (Some("BYTES"), base64.encode(b.value.array(), b.value.position(), b.value.remaining()))
case I16.value => (Some("I16"), b.value.getShort(0))
case I32.value => (Some("I32"), b.value.getInt(0))
case I64.value => (Some("I64"), b.value.getLong(0))
case Double.value => (Some("DOUBLE"), b.value.getDouble(0))
case String.value => (None, new String(b.value.array(), b.value.position(), b.value.remaining(), Utf8))
case _ => throw new Exception("Unsupported annotation type: %s".format(b))
}
} catch {
case e: Exception => "Error parsing binary annotation: %s".format(exceptionString(e))
}
JsonBinaryAnnotation(b.key, value, annotationType, b.host.map(JsonEndpoint))
}
def invert(b: JsonBinaryAnnotation) = {
val annotationType = b.annotationType
.map(upperCamel.convert(_))
.map(AnnotationType.fromName(_))
.getOrElse(b.value match {
// The only json types that can be implicit are booleans and strings. Numbers vary in shape.
case bool: Boolean => Bool
case string: String => String
case _ => throw new IllegalArgumentException("Unsupported json annotation type: %s".format(b))
})
val bytes: ByteBuffer = try {
annotationType.value match {
case Bool.value => BinaryAnnotationValue(b.value.asInstanceOf[Boolean]).encode
case Bytes.value => ByteBuffer.wrap(base64.decode(b.value.asInstanceOf[String]))
case I16.value => BinaryAnnotationValue(b.value.asInstanceOf[Short]).encode
case I32.value => BinaryAnnotationValue(b.value.asInstanceOf[Int]).encode
case I64.value => BinaryAnnotationValue(b.value.asInstanceOf[Long]).encode
case Double.value => BinaryAnnotationValue(b.value.asInstanceOf[Double]).encode
case String.value => BinaryAnnotationValue(b.value.asInstanceOf[String]).encode
case _ => throw new IllegalArgumentException("Unsupported annotation type: %s".format(b))
}
} catch {
case e: Exception => BinaryAnnotationValue("Error parsing json binary annotation: %s".format(exceptionString(e))).encode
}
new BinaryAnnotation(b.key, bytes, annotationType, b.endpoint.map(JsonEndpoint.invert))
}
private[this] def exceptionString(e: Exception) =
"%s(%s)".format(e.getClass.getSimpleName, if (e.getMessage == null) "" else e.getMessage)
}
| {'content_hash': '103381a5554f126fa2e8dd8e65f991c2', 'timestamp': '', 'source': 'github', 'line_count': 70, 'max_line_length': 126, 'avg_line_length': 48.77142857142857, 'alnum_prop': 0.6745752782659636, 'repo_name': 'prat0318/zipkin', 'id': 'a69d0aef1078656de3e3226973aad8346b80ac83', 'size': '3414', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'zipkin-common/src/main/scala/com/twitter/zipkin/json/JsonBinaryAnnotation.scala', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'CSS', 'bytes': '24629'}, {'name': 'HTML', 'bytes': '18269'}, {'name': 'Java', 'bytes': '47962'}, {'name': 'JavaScript', 'bytes': '201941'}, {'name': 'Scala', 'bytes': '452429'}, {'name': 'Shell', 'bytes': '4059'}, {'name': 'Thrift', 'bytes': '18304'}]} |
<?php
namespace lithium\tests\mocks\core;
class MockMethodFiltering extends \lithium\core\Object {
public function method($data) {
$data[] = 'Starting outer method call';
$result = $this->_filter(__METHOD__, compact('data'), function($self, $params, $chain) {
$params['data'][] = 'Inside method implementation';
return $params['data'];
});
$result[] = 'Ending outer method call';
return $result;
}
public function method2() {
$filters =& $this->_methodFilters;
$method = function($self, $params, $chain) use (&$filters) {
return $filters;
};
return $this->_filter(__METHOD__, array(), $method);
}
public function manual($filters) {
$method = function($self, $params, $chain) {
return "Working";
};
return $this->_filter(__METHOD__, array(), $method, $filters);
}
}
?> | {'content_hash': '4ab0b4b26fb7f6326cb49a18e81afe4d', 'timestamp': '', 'source': 'github', 'line_count': 35, 'max_line_length': 90, 'avg_line_length': 23.34285714285714, 'alnum_prop': 0.6340269277845777, 'repo_name': 'davidpersson/lithium', 'id': '9d4200330ec65f3811710b9fa25af5feac75229e', 'size': '1020', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'tests/mocks/core/MockMethodFiltering.php', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'Batchfile', 'bytes': '247'}, {'name': 'PHP', 'bytes': '2998922'}, {'name': 'Shell', 'bytes': '303'}]} |
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32_HAL_LEGACY
#define __STM32_HAL_LEGACY
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/** @defgroup HAL_AES_Aliased_Defines HAL CRYP Aliased Defines maintained for legacy purpose
* @{
*/
#define AES_FLAG_RDERR CRYP_FLAG_RDERR
#define AES_FLAG_WRERR CRYP_FLAG_WRERR
#define AES_CLEARFLAG_CCF CRYP_CLEARFLAG_CCF
#define AES_CLEARFLAG_RDERR CRYP_CLEARFLAG_RDERR
#define AES_CLEARFLAG_WRERR CRYP_CLEARFLAG_WRERR
/**
* @}
*/
/** @defgroup HAL_ADC_Aliased_Defines HAL ADC Aliased Defines maintained for legacy purpose
* @{
*/
#define ADC_RESOLUTION12b ADC_RESOLUTION_12B
#define ADC_RESOLUTION10b ADC_RESOLUTION_10B
#define ADC_RESOLUTION8b ADC_RESOLUTION_8B
#define ADC_RESOLUTION6b ADC_RESOLUTION_6B
#define OVR_DATA_OVERWRITTEN ADC_OVR_DATA_OVERWRITTEN
#define OVR_DATA_PRESERVED ADC_OVR_DATA_PRESERVED
#define EOC_SINGLE_CONV ADC_EOC_SINGLE_CONV
#define EOC_SEQ_CONV ADC_EOC_SEQ_CONV
#define EOC_SINGLE_SEQ_CONV ADC_EOC_SINGLE_SEQ_CONV
#define REGULAR_GROUP ADC_REGULAR_GROUP
#define INJECTED_GROUP ADC_INJECTED_GROUP
#define REGULAR_INJECTED_GROUP ADC_REGULAR_INJECTED_GROUP
#define AWD_EVENT ADC_AWD_EVENT
#define AWD1_EVENT ADC_AWD1_EVENT
#define AWD2_EVENT ADC_AWD2_EVENT
#define AWD3_EVENT ADC_AWD3_EVENT
#define OVR_EVENT ADC_OVR_EVENT
#define JQOVF_EVENT ADC_JQOVF_EVENT
#define ALL_CHANNELS ADC_ALL_CHANNELS
#define REGULAR_CHANNELS ADC_REGULAR_CHANNELS
#define INJECTED_CHANNELS ADC_INJECTED_CHANNELS
#define SYSCFG_FLAG_SENSOR_ADC ADC_FLAG_SENSOR
#define SYSCFG_FLAG_VREF_ADC ADC_FLAG_VREFINT
#define ADC_CLOCKPRESCALER_PCLK_DIV1 ADC_CLOCK_SYNC_PCLK_DIV1
#define ADC_CLOCKPRESCALER_PCLK_DIV2 ADC_CLOCK_SYNC_PCLK_DIV2
#define ADC_CLOCKPRESCALER_PCLK_DIV4 ADC_CLOCK_SYNC_PCLK_DIV4
#define ADC_CLOCKPRESCALER_PCLK_DIV6 ADC_CLOCK_SYNC_PCLK_DIV6
#define ADC_CLOCKPRESCALER_PCLK_DIV8 ADC_CLOCK_SYNC_PCLK_DIV8
#define ADC_EXTERNALTRIG0_T6_TRGO ADC_EXTERNALTRIGCONV_T6_TRGO
#define ADC_EXTERNALTRIG1_T21_CC2 ADC_EXTERNALTRIGCONV_T21_CC2
#define ADC_EXTERNALTRIG2_T2_TRGO ADC_EXTERNALTRIGCONV_T2_TRGO
#define ADC_EXTERNALTRIG3_T2_CC4 ADC_EXTERNALTRIGCONV_T2_CC4
#define ADC_EXTERNALTRIG4_T22_TRGO ADC_EXTERNALTRIGCONV_T22_TRGO
#define ADC_EXTERNALTRIG7_EXT_IT11 ADC_EXTERNALTRIGCONV_EXT_IT11
#define ADC_CLOCK_ASYNC ADC_CLOCK_ASYNC_DIV1
#define ADC_EXTERNALTRIG_EDGE_NONE ADC_EXTERNALTRIGCONVEDGE_NONE
#define ADC_EXTERNALTRIG_EDGE_RISING ADC_EXTERNALTRIGCONVEDGE_RISING
#define ADC_EXTERNALTRIG_EDGE_FALLING ADC_EXTERNALTRIGCONVEDGE_FALLING
#define ADC_EXTERNALTRIG_EDGE_RISINGFALLING ADC_EXTERNALTRIGCONVEDGE_RISINGFALLING
#define ADC_SAMPLETIME_2CYCLE_5 ADC_SAMPLETIME_2CYCLES_5
#define HAL_ADC_STATE_BUSY_REG HAL_ADC_STATE_REG_BUSY
#define HAL_ADC_STATE_BUSY_INJ HAL_ADC_STATE_INJ_BUSY
#define HAL_ADC_STATE_EOC_REG HAL_ADC_STATE_REG_EOC
#define HAL_ADC_STATE_EOC_INJ HAL_ADC_STATE_INJ_EOC
#define HAL_ADC_STATE_ERROR HAL_ADC_STATE_ERROR_INTERNAL
#define HAL_ADC_STATE_BUSY HAL_ADC_STATE_BUSY_INTERNAL
#define HAL_ADC_STATE_AWD HAL_ADC_STATE_AWD1
/**
* @}
*/
/** @defgroup HAL_CEC_Aliased_Defines HAL CEC Aliased Defines maintained for legacy purpose
* @{
*/
#define __HAL_CEC_GET_IT __HAL_CEC_GET_FLAG
/**
* @}
*/
/** @defgroup HAL_COMP_Aliased_Defines HAL COMP Aliased Defines maintained for legacy purpose
* @{
*/
#define COMP_WINDOWMODE_DISABLED COMP_WINDOWMODE_DISABLE
#define COMP_WINDOWMODE_ENABLED COMP_WINDOWMODE_ENABLE
#define COMP_EXTI_LINE_COMP1_EVENT COMP_EXTI_LINE_COMP1
#define COMP_EXTI_LINE_COMP2_EVENT COMP_EXTI_LINE_COMP2
#define COMP_EXTI_LINE_COMP3_EVENT COMP_EXTI_LINE_COMP3
#define COMP_EXTI_LINE_COMP4_EVENT COMP_EXTI_LINE_COMP4
#define COMP_EXTI_LINE_COMP5_EVENT COMP_EXTI_LINE_COMP5
#define COMP_EXTI_LINE_COMP6_EVENT COMP_EXTI_LINE_COMP6
#define COMP_EXTI_LINE_COMP7_EVENT COMP_EXTI_LINE_COMP7
#if defined(STM32L0)
#define COMP_LPTIMCONNECTION_ENABLED ((uint32_t)0x00000003U) /*!< COMPX output generic naming: connected to LPTIM input 1 for COMP1, LPTIM input 2 for COMP2 */
#endif
#define COMP_OUTPUT_COMP6TIM2OCREFCLR COMP_OUTPUT_COMP6_TIM2OCREFCLR
#if defined(STM32F373xC) || defined(STM32F378xx)
#define COMP_OUTPUT_TIM3IC1 COMP_OUTPUT_COMP1_TIM3IC1
#define COMP_OUTPUT_TIM3OCREFCLR COMP_OUTPUT_COMP1_TIM3OCREFCLR
#endif /* STM32F373xC || STM32F378xx */
#if defined(STM32L0) || defined(STM32L4)
#define COMP_WINDOWMODE_ENABLE COMP_WINDOWMODE_COMP1_INPUT_PLUS_COMMON
#define COMP_NONINVERTINGINPUT_IO1 COMP_INPUT_PLUS_IO1
#define COMP_NONINVERTINGINPUT_IO2 COMP_INPUT_PLUS_IO2
#define COMP_NONINVERTINGINPUT_IO3 COMP_INPUT_PLUS_IO3
#define COMP_NONINVERTINGINPUT_IO4 COMP_INPUT_PLUS_IO4
#define COMP_NONINVERTINGINPUT_IO5 COMP_INPUT_PLUS_IO5
#define COMP_NONINVERTINGINPUT_IO6 COMP_INPUT_PLUS_IO6
#define COMP_INVERTINGINPUT_1_4VREFINT COMP_INPUT_MINUS_1_4VREFINT
#define COMP_INVERTINGINPUT_1_2VREFINT COMP_INPUT_MINUS_1_2VREFINT
#define COMP_INVERTINGINPUT_3_4VREFINT COMP_INPUT_MINUS_3_4VREFINT
#define COMP_INVERTINGINPUT_VREFINT COMP_INPUT_MINUS_VREFINT
#define COMP_INVERTINGINPUT_DAC1_CH1 COMP_INPUT_MINUS_DAC1_CH1
#define COMP_INVERTINGINPUT_DAC1_CH2 COMP_INPUT_MINUS_DAC1_CH2
#define COMP_INVERTINGINPUT_DAC1 COMP_INPUT_MINUS_DAC1_CH1
#define COMP_INVERTINGINPUT_DAC2 COMP_INPUT_MINUS_DAC1_CH2
#define COMP_INVERTINGINPUT_IO1 COMP_INPUT_MINUS_IO1
#if defined(STM32L0)
/* Issue fixed on STM32L0 COMP driver: only 2 dedicated IO (IO1 and IO2), */
/* IO2 was wrongly assigned to IO shared with DAC and IO3 was corresponding */
/* to the second dedicated IO (only for COMP2). */
#define COMP_INVERTINGINPUT_IO2 COMP_INPUT_MINUS_DAC1_CH2
#define COMP_INVERTINGINPUT_IO3 COMP_INPUT_MINUS_IO2
#else
#define COMP_INVERTINGINPUT_IO2 COMP_INPUT_MINUS_IO2
#define COMP_INVERTINGINPUT_IO3 COMP_INPUT_MINUS_IO3
#endif
#define COMP_INVERTINGINPUT_IO4 COMP_INPUT_MINUS_IO4
#define COMP_INVERTINGINPUT_IO5 COMP_INPUT_MINUS_IO5
#define COMP_OUTPUTLEVEL_LOW COMP_OUTPUT_LEVEL_LOW
#define COMP_OUTPUTLEVEL_HIGH COMP_OUTPUT_LEVEL_HIGH
/* Note: Literal "COMP_FLAG_LOCK" kept for legacy purpose. */
/* To check COMP lock state, use macro "__HAL_COMP_IS_LOCKED()". */
#if defined(COMP_CSR_LOCK)
#define COMP_FLAG_LOCK COMP_CSR_LOCK
#elif defined(COMP_CSR_COMP1LOCK)
#define COMP_FLAG_LOCK COMP_CSR_COMP1LOCK
#elif defined(COMP_CSR_COMPxLOCK)
#define COMP_FLAG_LOCK COMP_CSR_COMPxLOCK
#endif
#if defined(STM32L4)
#define COMP_BLANKINGSRCE_TIM1OC5 COMP_BLANKINGSRC_TIM1_OC5_COMP1
#define COMP_BLANKINGSRCE_TIM2OC3 COMP_BLANKINGSRC_TIM2_OC3_COMP1
#define COMP_BLANKINGSRCE_TIM3OC3 COMP_BLANKINGSRC_TIM3_OC3_COMP1
#define COMP_BLANKINGSRCE_TIM3OC4 COMP_BLANKINGSRC_TIM3_OC4_COMP2
#define COMP_BLANKINGSRCE_TIM8OC5 COMP_BLANKINGSRC_TIM8_OC5_COMP2
#define COMP_BLANKINGSRCE_TIM15OC1 COMP_BLANKINGSRC_TIM15_OC1_COMP2
#define COMP_BLANKINGSRCE_NONE COMP_BLANKINGSRC_NONE
#endif
#if defined(STM32L0)
#define COMP_MODE_HIGHSPEED COMP_POWERMODE_MEDIUMSPEED
#define COMP_MODE_LOWSPEED COMP_POWERMODE_ULTRALOWPOWER
#else
#define COMP_MODE_HIGHSPEED COMP_POWERMODE_HIGHSPEED
#define COMP_MODE_MEDIUMSPEED COMP_POWERMODE_MEDIUMSPEED
#define COMP_MODE_LOWPOWER COMP_POWERMODE_LOWPOWER
#define COMP_MODE_ULTRALOWPOWER COMP_POWERMODE_ULTRALOWPOWER
#endif
#endif
/**
* @}
*/
/** @defgroup HAL_CORTEX_Aliased_Defines HAL CORTEX Aliased Defines maintained for legacy purpose
* @{
*/
#define __HAL_CORTEX_SYSTICKCLK_CONFIG HAL_SYSTICK_CLKSourceConfig
/**
* @}
*/
/** @defgroup HAL_CRC_Aliased_Defines HAL CRC Aliased Defines maintained for legacy purpose
* @{
*/
#define CRC_OUTPUTDATA_INVERSION_DISABLED CRC_OUTPUTDATA_INVERSION_DISABLE
#define CRC_OUTPUTDATA_INVERSION_ENABLED CRC_OUTPUTDATA_INVERSION_ENABLE
/**
* @}
*/
/** @defgroup HAL_DAC_Aliased_Defines HAL DAC Aliased Defines maintained for legacy purpose
* @{
*/
#define DAC1_CHANNEL_1 DAC_CHANNEL_1
#define DAC1_CHANNEL_2 DAC_CHANNEL_2
#define DAC2_CHANNEL_1 DAC_CHANNEL_1
#define DAC_WAVE_NONE ((uint32_t)0x00000000U)
#define DAC_WAVE_NOISE ((uint32_t)DAC_CR_WAVE1_0)
#define DAC_WAVE_TRIANGLE ((uint32_t)DAC_CR_WAVE1_1)
#define DAC_WAVEGENERATION_NONE DAC_WAVE_NONE
#define DAC_WAVEGENERATION_NOISE DAC_WAVE_NOISE
#define DAC_WAVEGENERATION_TRIANGLE DAC_WAVE_TRIANGLE
/**
* @}
*/
/** @defgroup HAL_DMA_Aliased_Defines HAL DMA Aliased Defines maintained for legacy purpose
* @{
*/
#define HAL_REMAPDMA_ADC_DMA_CH2 DMA_REMAP_ADC_DMA_CH2
#define HAL_REMAPDMA_USART1_TX_DMA_CH4 DMA_REMAP_USART1_TX_DMA_CH4
#define HAL_REMAPDMA_USART1_RX_DMA_CH5 DMA_REMAP_USART1_RX_DMA_CH5
#define HAL_REMAPDMA_TIM16_DMA_CH4 DMA_REMAP_TIM16_DMA_CH4
#define HAL_REMAPDMA_TIM17_DMA_CH2 DMA_REMAP_TIM17_DMA_CH2
#define HAL_REMAPDMA_USART3_DMA_CH32 DMA_REMAP_USART3_DMA_CH32
#define HAL_REMAPDMA_TIM16_DMA_CH6 DMA_REMAP_TIM16_DMA_CH6
#define HAL_REMAPDMA_TIM17_DMA_CH7 DMA_REMAP_TIM17_DMA_CH7
#define HAL_REMAPDMA_SPI2_DMA_CH67 DMA_REMAP_SPI2_DMA_CH67
#define HAL_REMAPDMA_USART2_DMA_CH67 DMA_REMAP_USART2_DMA_CH67
#define HAL_REMAPDMA_I2C1_DMA_CH76 DMA_REMAP_I2C1_DMA_CH76
#define HAL_REMAPDMA_TIM1_DMA_CH6 DMA_REMAP_TIM1_DMA_CH6
#define HAL_REMAPDMA_TIM2_DMA_CH7 DMA_REMAP_TIM2_DMA_CH7
#define HAL_REMAPDMA_TIM3_DMA_CH6 DMA_REMAP_TIM3_DMA_CH6
#define IS_HAL_REMAPDMA IS_DMA_REMAP
#define __HAL_REMAPDMA_CHANNEL_ENABLE __HAL_DMA_REMAP_CHANNEL_ENABLE
#define __HAL_REMAPDMA_CHANNEL_DISABLE __HAL_DMA_REMAP_CHANNEL_DISABLE
/**
* @}
*/
/** @defgroup HAL_FLASH_Aliased_Defines HAL FLASH Aliased Defines maintained for legacy purpose
* @{
*/
#define TYPEPROGRAM_BYTE FLASH_TYPEPROGRAM_BYTE
#define TYPEPROGRAM_HALFWORD FLASH_TYPEPROGRAM_HALFWORD
#define TYPEPROGRAM_WORD FLASH_TYPEPROGRAM_WORD
#define TYPEPROGRAM_DOUBLEWORD FLASH_TYPEPROGRAM_DOUBLEWORD
#define TYPEERASE_SECTORS FLASH_TYPEERASE_SECTORS
#define TYPEERASE_PAGES FLASH_TYPEERASE_PAGES
#define TYPEERASE_PAGEERASE FLASH_TYPEERASE_PAGES
#define TYPEERASE_MASSERASE FLASH_TYPEERASE_MASSERASE
#define WRPSTATE_DISABLE OB_WRPSTATE_DISABLE
#define WRPSTATE_ENABLE OB_WRPSTATE_ENABLE
#define HAL_FLASH_TIMEOUT_VALUE FLASH_TIMEOUT_VALUE
#define OBEX_PCROP OPTIONBYTE_PCROP
#define OBEX_BOOTCONFIG OPTIONBYTE_BOOTCONFIG
#define PCROPSTATE_DISABLE OB_PCROP_STATE_DISABLE
#define PCROPSTATE_ENABLE OB_PCROP_STATE_ENABLE
#define TYPEERASEDATA_BYTE FLASH_TYPEERASEDATA_BYTE
#define TYPEERASEDATA_HALFWORD FLASH_TYPEERASEDATA_HALFWORD
#define TYPEERASEDATA_WORD FLASH_TYPEERASEDATA_WORD
#define TYPEPROGRAMDATA_BYTE FLASH_TYPEPROGRAMDATA_BYTE
#define TYPEPROGRAMDATA_HALFWORD FLASH_TYPEPROGRAMDATA_HALFWORD
#define TYPEPROGRAMDATA_WORD FLASH_TYPEPROGRAMDATA_WORD
#define TYPEPROGRAMDATA_FASTBYTE FLASH_TYPEPROGRAMDATA_FASTBYTE
#define TYPEPROGRAMDATA_FASTHALFWORD FLASH_TYPEPROGRAMDATA_FASTHALFWORD
#define TYPEPROGRAMDATA_FASTWORD FLASH_TYPEPROGRAMDATA_FASTWORD
#define PAGESIZE FLASH_PAGE_SIZE
#define TYPEPROGRAM_FASTBYTE FLASH_TYPEPROGRAM_BYTE
#define TYPEPROGRAM_FASTHALFWORD FLASH_TYPEPROGRAM_HALFWORD
#define TYPEPROGRAM_FASTWORD FLASH_TYPEPROGRAM_WORD
#define VOLTAGE_RANGE_1 FLASH_VOLTAGE_RANGE_1
#define VOLTAGE_RANGE_2 FLASH_VOLTAGE_RANGE_2
#define VOLTAGE_RANGE_3 FLASH_VOLTAGE_RANGE_3
#define VOLTAGE_RANGE_4 FLASH_VOLTAGE_RANGE_4
#define TYPEPROGRAM_FAST FLASH_TYPEPROGRAM_FAST
#define TYPEPROGRAM_FAST_AND_LAST FLASH_TYPEPROGRAM_FAST_AND_LAST
#define WRPAREA_BANK1_AREAA OB_WRPAREA_BANK1_AREAA
#define WRPAREA_BANK1_AREAB OB_WRPAREA_BANK1_AREAB
#define WRPAREA_BANK2_AREAA OB_WRPAREA_BANK2_AREAA
#define WRPAREA_BANK2_AREAB OB_WRPAREA_BANK2_AREAB
#define IWDG_STDBY_FREEZE OB_IWDG_STDBY_FREEZE
#define IWDG_STDBY_ACTIVE OB_IWDG_STDBY_RUN
#define IWDG_STOP_FREEZE OB_IWDG_STOP_FREEZE
#define IWDG_STOP_ACTIVE OB_IWDG_STOP_RUN
#define FLASH_ERROR_NONE HAL_FLASH_ERROR_NONE
#define FLASH_ERROR_RD HAL_FLASH_ERROR_RD
#define FLASH_ERROR_PG HAL_FLASH_ERROR_PROG
#define FLASH_ERROR_PGP HAL_FLASH_ERROR_PGS
#define FLASH_ERROR_WRP HAL_FLASH_ERROR_WRP
#define FLASH_ERROR_OPTV HAL_FLASH_ERROR_OPTV
#define FLASH_ERROR_OPTVUSR HAL_FLASH_ERROR_OPTVUSR
#define FLASH_ERROR_PROG HAL_FLASH_ERROR_PROG
#define FLASH_ERROR_OP HAL_FLASH_ERROR_OPERATION
#define FLASH_ERROR_PGA HAL_FLASH_ERROR_PGA
#define FLASH_ERROR_SIZE HAL_FLASH_ERROR_SIZE
#define FLASH_ERROR_SIZ HAL_FLASH_ERROR_SIZE
#define FLASH_ERROR_PGS HAL_FLASH_ERROR_PGS
#define FLASH_ERROR_MIS HAL_FLASH_ERROR_MIS
#define FLASH_ERROR_FAST HAL_FLASH_ERROR_FAST
#define FLASH_ERROR_FWWERR HAL_FLASH_ERROR_FWWERR
#define FLASH_ERROR_NOTZERO HAL_FLASH_ERROR_NOTZERO
#define FLASH_ERROR_OPERATION HAL_FLASH_ERROR_OPERATION
#define FLASH_ERROR_ERS HAL_FLASH_ERROR_ERS
#define OB_WDG_SW OB_IWDG_SW
#define OB_WDG_HW OB_IWDG_HW
#define OB_SDADC12_VDD_MONITOR_SET OB_SDACD_VDD_MONITOR_SET
#define OB_SDADC12_VDD_MONITOR_RESET OB_SDACD_VDD_MONITOR_RESET
#define OB_RAM_PARITY_CHECK_SET OB_SRAM_PARITY_SET
#define OB_RAM_PARITY_CHECK_RESET OB_SRAM_PARITY_RESET
#define IS_OB_SDADC12_VDD_MONITOR IS_OB_SDACD_VDD_MONITOR
#define OB_RDP_LEVEL0 OB_RDP_LEVEL_0
#define OB_RDP_LEVEL1 OB_RDP_LEVEL_1
#define OB_RDP_LEVEL2 OB_RDP_LEVEL_2
/**
* @}
*/
/** @defgroup HAL_SYSCFG_Aliased_Defines HAL SYSCFG Aliased Defines maintained for legacy purpose
* @{
*/
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PA9 I2C_FASTMODEPLUS_PA9
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PA10 I2C_FASTMODEPLUS_PA10
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PB6 I2C_FASTMODEPLUS_PB6
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PB7 I2C_FASTMODEPLUS_PB7
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PB8 I2C_FASTMODEPLUS_PB8
#define HAL_SYSCFG_FASTMODEPLUS_I2C_PB9 I2C_FASTMODEPLUS_PB9
#define HAL_SYSCFG_FASTMODEPLUS_I2C1 I2C_FASTMODEPLUS_I2C1
#define HAL_SYSCFG_FASTMODEPLUS_I2C2 I2C_FASTMODEPLUS_I2C2
#define HAL_SYSCFG_FASTMODEPLUS_I2C3 I2C_FASTMODEPLUS_I2C3
/**
* @}
*/
/** @defgroup LL_FMC_Aliased_Defines LL FMC Aliased Defines maintained for compatibility purpose
* @{
*/
#if defined(STM32L4) || defined(STM32F7)
#define FMC_NAND_PCC_WAIT_FEATURE_DISABLE FMC_NAND_WAIT_FEATURE_DISABLE
#define FMC_NAND_PCC_WAIT_FEATURE_ENABLE FMC_NAND_WAIT_FEATURE_ENABLE
#define FMC_NAND_PCC_MEM_BUS_WIDTH_8 FMC_NAND_MEM_BUS_WIDTH_8
#define FMC_NAND_PCC_MEM_BUS_WIDTH_16 FMC_NAND_MEM_BUS_WIDTH_16
#else
#define FMC_NAND_WAIT_FEATURE_DISABLE FMC_NAND_PCC_WAIT_FEATURE_DISABLE
#define FMC_NAND_WAIT_FEATURE_ENABLE FMC_NAND_PCC_WAIT_FEATURE_ENABLE
#define FMC_NAND_MEM_BUS_WIDTH_8 FMC_NAND_PCC_MEM_BUS_WIDTH_8
#define FMC_NAND_MEM_BUS_WIDTH_16 FMC_NAND_PCC_MEM_BUS_WIDTH_16
#endif
/**
* @}
*/
/** @defgroup LL_FSMC_Aliased_Defines LL FSMC Aliased Defines maintained for legacy purpose
* @{
*/
#define FSMC_NORSRAM_TYPEDEF FSMC_NORSRAM_TypeDef
#define FSMC_NORSRAM_EXTENDED_TYPEDEF FSMC_NORSRAM_EXTENDED_TypeDef
/**
* @}
*/
/** @defgroup HAL_GPIO_Aliased_Macros HAL GPIO Aliased Macros maintained for legacy purpose
* @{
*/
#define GET_GPIO_SOURCE GPIO_GET_INDEX
#define GET_GPIO_INDEX GPIO_GET_INDEX
#if defined(STM32F4)
#define GPIO_AF12_SDMMC GPIO_AF12_SDIO
#define GPIO_AF12_SDMMC1 GPIO_AF12_SDIO
#endif
#if defined(STM32F7)
#define GPIO_AF12_SDIO GPIO_AF12_SDMMC1
#define GPIO_AF12_SDMMC GPIO_AF12_SDMMC1
#endif
#if defined(STM32L4)
#define GPIO_AF12_SDIO GPIO_AF12_SDMMC1
#define GPIO_AF12_SDMMC GPIO_AF12_SDMMC1
#endif
#define GPIO_AF0_LPTIM GPIO_AF0_LPTIM1
#define GPIO_AF1_LPTIM GPIO_AF1_LPTIM1
#define GPIO_AF2_LPTIM GPIO_AF2_LPTIM1
#if defined(STM32L0) || defined(STM32L4) || defined(STM32F4) || defined(STM32F2) || defined(STM32F7)
#define GPIO_SPEED_LOW GPIO_SPEED_FREQ_LOW
#define GPIO_SPEED_MEDIUM GPIO_SPEED_FREQ_MEDIUM
#define GPIO_SPEED_FAST GPIO_SPEED_FREQ_HIGH
#define GPIO_SPEED_HIGH GPIO_SPEED_FREQ_VERY_HIGH
#endif /* STM32L0 || STM32L4 || STM32F4 || STM32F2 || STM32F7 */
#if defined(STM32L1)
#define GPIO_SPEED_VERY_LOW GPIO_SPEED_FREQ_LOW
#define GPIO_SPEED_LOW GPIO_SPEED_FREQ_MEDIUM
#define GPIO_SPEED_MEDIUM GPIO_SPEED_FREQ_HIGH
#define GPIO_SPEED_HIGH GPIO_SPEED_FREQ_VERY_HIGH
#endif /* STM32L1 */
#if defined(STM32F0) || defined(STM32F3) || defined(STM32F1)
#define GPIO_SPEED_LOW GPIO_SPEED_FREQ_LOW
#define GPIO_SPEED_MEDIUM GPIO_SPEED_FREQ_MEDIUM
#define GPIO_SPEED_HIGH GPIO_SPEED_FREQ_HIGH
#endif /* STM32F0 || STM32F3 || STM32F1 */
#define GPIO_AF6_DFSDM GPIO_AF6_DFSDM1
/**
* @}
*/
/** @defgroup HAL_JPEG_Aliased_Macros HAL JPEG Aliased Macros maintained for legacy purpose
* @{
*/
#if defined(STM32H7)
#define __HAL_RCC_JPEG_CLK_ENABLE __HAL_RCC_JPGDECEN_CLK_ENABLE
#define __HAL_RCC_JPEG_CLK_DISABLE __HAL_RCC_JPGDECEN_CLK_DISABLE
#define __HAL_RCC_JPEG_FORCE_RESET __HAL_RCC_JPGDECRST_FORCE_RESET
#define __HAL_RCC_JPEG_RELEASE_RESET __HAL_RCC_JPGDECRST_RELEASE_RESET
#define __HAL_RCC_JPEG_CLK_SLEEP_ENABLE __HAL_RCC_JPGDEC_CLK_SLEEP_ENABLE
#define __HAL_RCC_JPEG_CLK_SLEEP_DISABLE __HAL_RCC_JPGDEC_CLK_SLEEP_DISABLE
#define DMA_REQUEST_DAC1 DMA_REQUEST_DAC1_CH1
#define DMA_REQUEST_DAC2 DMA_REQUEST_DAC1_CH2
#define BDMA_REQUEST_LP_UART1_RX BDMA_REQUEST_LPUART1_RX
#define BDMA_REQUEST_LP_UART1_TX BDMA_REQUEST_LPUART1_TX
#define HAL_DMAMUX1_REQUEST_GEN_DMAMUX1_CH0_EVT HAL_DMAMUX1_REQ_GEN_DMAMUX1_CH0_EVT
#define HAL_DMAMUX1_REQUEST_GEN_DMAMUX1_CH1_EVT HAL_DMAMUX1_REQ_GEN_DMAMUX1_CH1_EVT
#define HAL_DMAMUX1_REQUEST_GEN_DMAMUX1_CH2_EVT HAL_DMAMUX1_REQ_GEN_DMAMUX1_CH2_EVT
#define HAL_DMAMUX1_REQUEST_GEN_LPTIM1_OUT HAL_DMAMUX1_REQ_GEN_LPTIM1_OUT
#define HAL_DMAMUX1_REQUEST_GEN_LPTIM2_OUT HAL_DMAMUX1_REQ_GEN_LPTIM2_OUT
#define HAL_DMAMUX1_REQUEST_GEN_LPTIM3_OUT HAL_DMAMUX1_REQ_GEN_LPTIM3_OUT
#define HAL_DMAMUX1_REQUEST_GEN_EXTI0 HAL_DMAMUX1_REQ_GEN_EXTI0
#define HAL_DMAMUX1_REQUEST_GEN_TIM12_TRGO HAL_DMAMUX1_REQ_GEN_TIM12_TRGO
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH0_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH0_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH1_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH1_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH2_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH2_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH3_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH3_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH4_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH4_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH5_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH5_EVT
#define HAL_DMAMUX2_REQUEST_GEN_DMAMUX2_CH6_EVT HAL_DMAMUX2_REQ_GEN_DMAMUX2_CH6_EVT
#define HAL_DMAMUX2_REQUEST_GEN_LPUART1_RX_WKUP HAL_DMAMUX2_REQ_GEN_LPUART1_RX_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_LPUART1_TX_WKUP HAL_DMAMUX2_REQ_GEN_LPUART1_TX_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM2_WKUP HAL_DMAMUX2_REQ_GEN_LPTIM2_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM2_OUT HAL_DMAMUX2_REQ_GEN_LPTIM2_OUT
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM3_WKUP HAL_DMAMUX2_REQ_GEN_LPTIM3_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM3_OUT HAL_DMAMUX2_REQ_GEN_LPTIM3_OUT
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM4_WKUP HAL_DMAMUX2_REQ_GEN_LPTIM4_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_LPTIM5_WKUP HAL_DMAMUX2_REQ_GEN_LPTIM5_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_I2C4_WKUP HAL_DMAMUX2_REQ_GEN_I2C4_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_SPI6_WKUP HAL_DMAMUX2_REQ_GEN_SPI6_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_COMP1_OUT HAL_DMAMUX2_REQ_GEN_COMP1_OUT
#define HAL_DMAMUX2_REQUEST_GEN_COMP2_OUT HAL_DMAMUX2_REQ_GEN_COMP2_OUT
#define HAL_DMAMUX2_REQUEST_GEN_RTC_WKUP HAL_DMAMUX2_REQ_GEN_RTC_WKUP
#define HAL_DMAMUX2_REQUEST_GEN_EXTI0 HAL_DMAMUX2_REQ_GEN_EXTI0
#define HAL_DMAMUX2_REQUEST_GEN_EXTI2 HAL_DMAMUX2_REQ_GEN_EXTI2
#define HAL_DMAMUX2_REQUEST_GEN_I2C4_IT_EVT HAL_DMAMUX2_REQ_GEN_I2C4_IT_EVT
#define HAL_DMAMUX2_REQUEST_GEN_SPI6_IT HAL_DMAMUX2_REQ_GEN_SPI6_IT
#define HAL_DMAMUX2_REQUEST_GEN_LPUART1_TX_IT HAL_DMAMUX2_REQ_GEN_LPUART1_TX_IT
#define HAL_DMAMUX2_REQUEST_GEN_LPUART1_RX_IT HAL_DMAMUX2_REQ_GEN_LPUART1_RX_IT
#define HAL_DMAMUX2_REQUEST_GEN_ADC3_IT HAL_DMAMUX2_REQ_GEN_ADC3_IT
#define HAL_DMAMUX2_REQUEST_GEN_ADC3_AWD1_OUT HAL_DMAMUX2_REQ_GEN_ADC3_AWD1_OUT
#define HAL_DMAMUX2_REQUEST_GEN_BDMA_CH0_IT HAL_DMAMUX2_REQ_GEN_BDMA_CH0_IT
#define HAL_DMAMUX2_REQUEST_GEN_BDMA_CH1_IT HAL_DMAMUX2_REQ_GEN_BDMA_CH1_IT
#define HAL_DMAMUX_REQUEST_GEN_NO_EVENT HAL_DMAMUX_REQ_GEN_NO_EVENT
#define HAL_DMAMUX_REQUEST_GEN_RISING HAL_DMAMUX_REQ_GEN_RISING
#define HAL_DMAMUX_REQUEST_GEN_FALLING HAL_DMAMUX_REQ_GEN_FALLING
#define HAL_DMAMUX_REQUEST_GEN_RISING_FALLING HAL_DMAMUX_REQ_GEN_RISING_FALLING
#endif /* STM32H7 */
/**
* @}
*/
/** @defgroup HAL_HRTIM_Aliased_Macros HAL HRTIM Aliased Macros maintained for legacy purpose
* @{
*/
#define HRTIM_TIMDELAYEDPROTECTION_DISABLED HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DISABLED
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDOUT1_EEV68 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDOUT1_EEV6
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDOUT2_EEV68 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDOUT2_EEV6
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDBOTH_EEV68 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDBOTH_EEV6
#define HRTIM_TIMDELAYEDPROTECTION_BALANCED_EEV68 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_BALANCED_EEV6
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDOUT1_DEEV79 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDOUT1_DEEV7
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDOUT2_DEEV79 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDOUT2_DEEV7
#define HRTIM_TIMDELAYEDPROTECTION_DELAYEDBOTH_EEV79 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_DELAYEDBOTH_EEV7
#define HRTIM_TIMDELAYEDPROTECTION_BALANCED_EEV79 HRTIM_TIMER_A_B_C_DELAYEDPROTECTION_BALANCED_EEV7
#define __HAL_HRTIM_SetCounter __HAL_HRTIM_SETCOUNTER
#define __HAL_HRTIM_GetCounter __HAL_HRTIM_GETCOUNTER
#define __HAL_HRTIM_SetPeriod __HAL_HRTIM_SETPERIOD
#define __HAL_HRTIM_GetPeriod __HAL_HRTIM_GETPERIOD
#define __HAL_HRTIM_SetClockPrescaler __HAL_HRTIM_SETCLOCKPRESCALER
#define __HAL_HRTIM_GetClockPrescaler __HAL_HRTIM_GETCLOCKPRESCALER
#define __HAL_HRTIM_SetCompare __HAL_HRTIM_SETCOMPARE
#define __HAL_HRTIM_GetCompare __HAL_HRTIM_GETCOMPARE
/**
* @}
*/
/** @defgroup HAL_I2C_Aliased_Defines HAL I2C Aliased Defines maintained for legacy purpose
* @{
*/
#define I2C_DUALADDRESS_DISABLED I2C_DUALADDRESS_DISABLE
#define I2C_DUALADDRESS_ENABLED I2C_DUALADDRESS_ENABLE
#define I2C_GENERALCALL_DISABLED I2C_GENERALCALL_DISABLE
#define I2C_GENERALCALL_ENABLED I2C_GENERALCALL_ENABLE
#define I2C_NOSTRETCH_DISABLED I2C_NOSTRETCH_DISABLE
#define I2C_NOSTRETCH_ENABLED I2C_NOSTRETCH_ENABLE
#define I2C_ANALOGFILTER_ENABLED I2C_ANALOGFILTER_ENABLE
#define I2C_ANALOGFILTER_DISABLED I2C_ANALOGFILTER_DISABLE
#if defined(STM32F0) || defined(STM32F1) || defined(STM32F3) || defined(STM32G0) || defined(STM32L4) || defined(STM32L1) || defined(STM32F7)
#define HAL_I2C_STATE_MEM_BUSY_TX HAL_I2C_STATE_BUSY_TX
#define HAL_I2C_STATE_MEM_BUSY_RX HAL_I2C_STATE_BUSY_RX
#define HAL_I2C_STATE_MASTER_BUSY_TX HAL_I2C_STATE_BUSY_TX
#define HAL_I2C_STATE_MASTER_BUSY_RX HAL_I2C_STATE_BUSY_RX
#define HAL_I2C_STATE_SLAVE_BUSY_TX HAL_I2C_STATE_BUSY_TX
#define HAL_I2C_STATE_SLAVE_BUSY_RX HAL_I2C_STATE_BUSY_RX
#endif
/**
* @}
*/
/** @defgroup HAL_IRDA_Aliased_Defines HAL IRDA Aliased Defines maintained for legacy purpose
* @{
*/
#define IRDA_ONE_BIT_SAMPLE_DISABLED IRDA_ONE_BIT_SAMPLE_DISABLE
#define IRDA_ONE_BIT_SAMPLE_ENABLED IRDA_ONE_BIT_SAMPLE_ENABLE
/**
* @}
*/
/** @defgroup HAL_IWDG_Aliased_Defines HAL IWDG Aliased Defines maintained for legacy purpose
* @{
*/
#define KR_KEY_RELOAD IWDG_KEY_RELOAD
#define KR_KEY_ENABLE IWDG_KEY_ENABLE
#define KR_KEY_EWA IWDG_KEY_WRITE_ACCESS_ENABLE
#define KR_KEY_DWA IWDG_KEY_WRITE_ACCESS_DISABLE
/**
* @}
*/
/** @defgroup HAL_LPTIM_Aliased_Defines HAL LPTIM Aliased Defines maintained for legacy purpose
* @{
*/
#define LPTIM_CLOCKSAMPLETIME_DIRECTTRANSISTION LPTIM_CLOCKSAMPLETIME_DIRECTTRANSITION
#define LPTIM_CLOCKSAMPLETIME_2TRANSISTIONS LPTIM_CLOCKSAMPLETIME_2TRANSITIONS
#define LPTIM_CLOCKSAMPLETIME_4TRANSISTIONS LPTIM_CLOCKSAMPLETIME_4TRANSITIONS
#define LPTIM_CLOCKSAMPLETIME_8TRANSISTIONS LPTIM_CLOCKSAMPLETIME_8TRANSITIONS
#define LPTIM_CLOCKPOLARITY_RISINGEDGE LPTIM_CLOCKPOLARITY_RISING
#define LPTIM_CLOCKPOLARITY_FALLINGEDGE LPTIM_CLOCKPOLARITY_FALLING
#define LPTIM_CLOCKPOLARITY_BOTHEDGES LPTIM_CLOCKPOLARITY_RISING_FALLING
#define LPTIM_TRIGSAMPLETIME_DIRECTTRANSISTION LPTIM_TRIGSAMPLETIME_DIRECTTRANSITION
#define LPTIM_TRIGSAMPLETIME_2TRANSISTIONS LPTIM_TRIGSAMPLETIME_2TRANSITIONS
#define LPTIM_TRIGSAMPLETIME_4TRANSISTIONS LPTIM_TRIGSAMPLETIME_4TRANSITIONS
#define LPTIM_TRIGSAMPLETIME_8TRANSISTIONS LPTIM_TRIGSAMPLETIME_8TRANSITIONS
/* The following 3 definition have also been present in a temporary version of lptim.h */
/* They need to be renamed also to the right name, just in case */
#define LPTIM_TRIGSAMPLETIME_2TRANSITION LPTIM_TRIGSAMPLETIME_2TRANSITIONS
#define LPTIM_TRIGSAMPLETIME_4TRANSITION LPTIM_TRIGSAMPLETIME_4TRANSITIONS
#define LPTIM_TRIGSAMPLETIME_8TRANSITION LPTIM_TRIGSAMPLETIME_8TRANSITIONS
/**
* @}
*/
/** @defgroup HAL_NAND_Aliased_Defines HAL NAND Aliased Defines maintained for legacy purpose
* @{
*/
#define HAL_NAND_Read_Page HAL_NAND_Read_Page_8b
#define HAL_NAND_Write_Page HAL_NAND_Write_Page_8b
#define HAL_NAND_Read_SpareArea HAL_NAND_Read_SpareArea_8b
#define HAL_NAND_Write_SpareArea HAL_NAND_Write_SpareArea_8b
#define NAND_AddressTypedef NAND_AddressTypeDef
#define __ARRAY_ADDRESS ARRAY_ADDRESS
#define __ADDR_1st_CYCLE ADDR_1ST_CYCLE
#define __ADDR_2nd_CYCLE ADDR_2ND_CYCLE
#define __ADDR_3rd_CYCLE ADDR_3RD_CYCLE
#define __ADDR_4th_CYCLE ADDR_4TH_CYCLE
/**
* @}
*/
/** @defgroup HAL_NOR_Aliased_Defines HAL NOR Aliased Defines maintained for legacy purpose
* @{
*/
#define NOR_StatusTypedef HAL_NOR_StatusTypeDef
#define NOR_SUCCESS HAL_NOR_STATUS_SUCCESS
#define NOR_ONGOING HAL_NOR_STATUS_ONGOING
#define NOR_ERROR HAL_NOR_STATUS_ERROR
#define NOR_TIMEOUT HAL_NOR_STATUS_TIMEOUT
#define __NOR_WRITE NOR_WRITE
#define __NOR_ADDR_SHIFT NOR_ADDR_SHIFT
/**
* @}
*/
/** @defgroup HAL_OPAMP_Aliased_Defines HAL OPAMP Aliased Defines maintained for legacy purpose
* @{
*/
#define OPAMP_NONINVERTINGINPUT_VP0 OPAMP_NONINVERTINGINPUT_IO0
#define OPAMP_NONINVERTINGINPUT_VP1 OPAMP_NONINVERTINGINPUT_IO1
#define OPAMP_NONINVERTINGINPUT_VP2 OPAMP_NONINVERTINGINPUT_IO2
#define OPAMP_NONINVERTINGINPUT_VP3 OPAMP_NONINVERTINGINPUT_IO3
#define OPAMP_SEC_NONINVERTINGINPUT_VP0 OPAMP_SEC_NONINVERTINGINPUT_IO0
#define OPAMP_SEC_NONINVERTINGINPUT_VP1 OPAMP_SEC_NONINVERTINGINPUT_IO1
#define OPAMP_SEC_NONINVERTINGINPUT_VP2 OPAMP_SEC_NONINVERTINGINPUT_IO2
#define OPAMP_SEC_NONINVERTINGINPUT_VP3 OPAMP_SEC_NONINVERTINGINPUT_IO3
#define OPAMP_INVERTINGINPUT_VM0 OPAMP_INVERTINGINPUT_IO0
#define OPAMP_INVERTINGINPUT_VM1 OPAMP_INVERTINGINPUT_IO1
#define IOPAMP_INVERTINGINPUT_VM0 OPAMP_INVERTINGINPUT_IO0
#define IOPAMP_INVERTINGINPUT_VM1 OPAMP_INVERTINGINPUT_IO1
#define OPAMP_SEC_INVERTINGINPUT_VM0 OPAMP_SEC_INVERTINGINPUT_IO0
#define OPAMP_SEC_INVERTINGINPUT_VM1 OPAMP_SEC_INVERTINGINPUT_IO1
#define OPAMP_INVERTINGINPUT_VINM OPAMP_SEC_INVERTINGINPUT_IO1
#define OPAMP_PGACONNECT_NO OPAMP_PGA_CONNECT_INVERTINGINPUT_NO
#define OPAMP_PGACONNECT_VM0 OPAMP_PGA_CONNECT_INVERTINGINPUT_IO0
#define OPAMP_PGACONNECT_VM1 OPAMP_PGA_CONNECT_INVERTINGINPUT_IO1
/**
* @}
*/
/** @defgroup HAL_I2S_Aliased_Defines HAL I2S Aliased Defines maintained for legacy purpose
* @{
*/
#define I2S_STANDARD_PHILLIPS I2S_STANDARD_PHILIPS
#if defined(STM32F7)
#define I2S_CLOCK_SYSCLK I2S_CLOCK_PLL
#endif
/**
* @}
*/
/** @defgroup HAL_PCCARD_Aliased_Defines HAL PCCARD Aliased Defines maintained for legacy purpose
* @{
*/
/* Compact Flash-ATA registers description */
#define CF_DATA ATA_DATA
#define CF_SECTOR_COUNT ATA_SECTOR_COUNT
#define CF_SECTOR_NUMBER ATA_SECTOR_NUMBER
#define CF_CYLINDER_LOW ATA_CYLINDER_LOW
#define CF_CYLINDER_HIGH ATA_CYLINDER_HIGH
#define CF_CARD_HEAD ATA_CARD_HEAD
#define CF_STATUS_CMD ATA_STATUS_CMD
#define CF_STATUS_CMD_ALTERNATE ATA_STATUS_CMD_ALTERNATE
#define CF_COMMON_DATA_AREA ATA_COMMON_DATA_AREA
/* Compact Flash-ATA commands */
#define CF_READ_SECTOR_CMD ATA_READ_SECTOR_CMD
#define CF_WRITE_SECTOR_CMD ATA_WRITE_SECTOR_CMD
#define CF_ERASE_SECTOR_CMD ATA_ERASE_SECTOR_CMD
#define CF_IDENTIFY_CMD ATA_IDENTIFY_CMD
#define PCCARD_StatusTypedef HAL_PCCARD_StatusTypeDef
#define PCCARD_SUCCESS HAL_PCCARD_STATUS_SUCCESS
#define PCCARD_ONGOING HAL_PCCARD_STATUS_ONGOING
#define PCCARD_ERROR HAL_PCCARD_STATUS_ERROR
#define PCCARD_TIMEOUT HAL_PCCARD_STATUS_TIMEOUT
/**
* @}
*/
/** @defgroup HAL_RTC_Aliased_Defines HAL RTC Aliased Defines maintained for legacy purpose
* @{
*/
#define FORMAT_BIN RTC_FORMAT_BIN
#define FORMAT_BCD RTC_FORMAT_BCD
#define RTC_ALARMSUBSECONDMASK_None RTC_ALARMSUBSECONDMASK_NONE
#define RTC_TAMPERERASEBACKUP_DISABLED RTC_TAMPER_ERASE_BACKUP_DISABLE
#define RTC_TAMPERMASK_FLAG_DISABLED RTC_TAMPERMASK_FLAG_DISABLE
#define RTC_TAMPERMASK_FLAG_ENABLED RTC_TAMPERMASK_FLAG_ENABLE
#define RTC_MASKTAMPERFLAG_DISABLED RTC_TAMPERMASK_FLAG_DISABLE
#define RTC_MASKTAMPERFLAG_ENABLED RTC_TAMPERMASK_FLAG_ENABLE
#define RTC_TAMPERERASEBACKUP_ENABLED RTC_TAMPER_ERASE_BACKUP_ENABLE
#define RTC_TAMPER1_2_INTERRUPT RTC_ALL_TAMPER_INTERRUPT
#define RTC_TAMPER1_2_3_INTERRUPT RTC_ALL_TAMPER_INTERRUPT
#define RTC_TIMESTAMPPIN_PC13 RTC_TIMESTAMPPIN_DEFAULT
#define RTC_TIMESTAMPPIN_PA0 RTC_TIMESTAMPPIN_POS1
#define RTC_TIMESTAMPPIN_PI8 RTC_TIMESTAMPPIN_POS1
#define RTC_TIMESTAMPPIN_PC1 RTC_TIMESTAMPPIN_POS2
#define RTC_OUTPUT_REMAP_PC13 RTC_OUTPUT_REMAP_NONE
#define RTC_OUTPUT_REMAP_PB14 RTC_OUTPUT_REMAP_POS1
#define RTC_OUTPUT_REMAP_PB2 RTC_OUTPUT_REMAP_POS1
#define RTC_TAMPERPIN_PC13 RTC_TAMPERPIN_DEFAULT
#define RTC_TAMPERPIN_PA0 RTC_TAMPERPIN_POS1
#define RTC_TAMPERPIN_PI8 RTC_TAMPERPIN_POS1
/**
* @}
*/
/** @defgroup HAL_SMARTCARD_Aliased_Defines HAL SMARTCARD Aliased Defines maintained for legacy purpose
* @{
*/
#define SMARTCARD_NACK_ENABLED SMARTCARD_NACK_ENABLE
#define SMARTCARD_NACK_DISABLED SMARTCARD_NACK_DISABLE
#define SMARTCARD_ONEBIT_SAMPLING_DISABLED SMARTCARD_ONE_BIT_SAMPLE_DISABLE
#define SMARTCARD_ONEBIT_SAMPLING_ENABLED SMARTCARD_ONE_BIT_SAMPLE_ENABLE
#define SMARTCARD_ONEBIT_SAMPLING_DISABLE SMARTCARD_ONE_BIT_SAMPLE_DISABLE
#define SMARTCARD_ONEBIT_SAMPLING_ENABLE SMARTCARD_ONE_BIT_SAMPLE_ENABLE
#define SMARTCARD_TIMEOUT_DISABLED SMARTCARD_TIMEOUT_DISABLE
#define SMARTCARD_TIMEOUT_ENABLED SMARTCARD_TIMEOUT_ENABLE
#define SMARTCARD_LASTBIT_DISABLED SMARTCARD_LASTBIT_DISABLE
#define SMARTCARD_LASTBIT_ENABLED SMARTCARD_LASTBIT_ENABLE
/**
* @}
*/
/** @defgroup HAL_SMBUS_Aliased_Defines HAL SMBUS Aliased Defines maintained for legacy purpose
* @{
*/
#define SMBUS_DUALADDRESS_DISABLED SMBUS_DUALADDRESS_DISABLE
#define SMBUS_DUALADDRESS_ENABLED SMBUS_DUALADDRESS_ENABLE
#define SMBUS_GENERALCALL_DISABLED SMBUS_GENERALCALL_DISABLE
#define SMBUS_GENERALCALL_ENABLED SMBUS_GENERALCALL_ENABLE
#define SMBUS_NOSTRETCH_DISABLED SMBUS_NOSTRETCH_DISABLE
#define SMBUS_NOSTRETCH_ENABLED SMBUS_NOSTRETCH_ENABLE
#define SMBUS_ANALOGFILTER_ENABLED SMBUS_ANALOGFILTER_ENABLE
#define SMBUS_ANALOGFILTER_DISABLED SMBUS_ANALOGFILTER_DISABLE
#define SMBUS_PEC_DISABLED SMBUS_PEC_DISABLE
#define SMBUS_PEC_ENABLED SMBUS_PEC_ENABLE
#define HAL_SMBUS_STATE_SLAVE_LISTEN HAL_SMBUS_STATE_LISTEN
/**
* @}
*/
/** @defgroup HAL_SPI_Aliased_Defines HAL SPI Aliased Defines maintained for legacy purpose
* @{
*/
#define SPI_TIMODE_DISABLED SPI_TIMODE_DISABLE
#define SPI_TIMODE_ENABLED SPI_TIMODE_ENABLE
#define SPI_CRCCALCULATION_DISABLED SPI_CRCCALCULATION_DISABLE
#define SPI_CRCCALCULATION_ENABLED SPI_CRCCALCULATION_ENABLE
#define SPI_NSS_PULSE_DISABLED SPI_NSS_PULSE_DISABLE
#define SPI_NSS_PULSE_ENABLED SPI_NSS_PULSE_ENABLE
/**
* @}
*/
/** @defgroup HAL_TIM_Aliased_Defines HAL TIM Aliased Defines maintained for legacy purpose
* @{
*/
#define CCER_CCxE_MASK TIM_CCER_CCxE_MASK
#define CCER_CCxNE_MASK TIM_CCER_CCxNE_MASK
#define TIM_DMABase_CR1 TIM_DMABASE_CR1
#define TIM_DMABase_CR2 TIM_DMABASE_CR2
#define TIM_DMABase_SMCR TIM_DMABASE_SMCR
#define TIM_DMABase_DIER TIM_DMABASE_DIER
#define TIM_DMABase_SR TIM_DMABASE_SR
#define TIM_DMABase_EGR TIM_DMABASE_EGR
#define TIM_DMABase_CCMR1 TIM_DMABASE_CCMR1
#define TIM_DMABase_CCMR2 TIM_DMABASE_CCMR2
#define TIM_DMABase_CCER TIM_DMABASE_CCER
#define TIM_DMABase_CNT TIM_DMABASE_CNT
#define TIM_DMABase_PSC TIM_DMABASE_PSC
#define TIM_DMABase_ARR TIM_DMABASE_ARR
#define TIM_DMABase_RCR TIM_DMABASE_RCR
#define TIM_DMABase_CCR1 TIM_DMABASE_CCR1
#define TIM_DMABase_CCR2 TIM_DMABASE_CCR2
#define TIM_DMABase_CCR3 TIM_DMABASE_CCR3
#define TIM_DMABase_CCR4 TIM_DMABASE_CCR4
#define TIM_DMABase_BDTR TIM_DMABASE_BDTR
#define TIM_DMABase_DCR TIM_DMABASE_DCR
#define TIM_DMABase_DMAR TIM_DMABASE_DMAR
#define TIM_DMABase_OR1 TIM_DMABASE_OR1
#define TIM_DMABase_CCMR3 TIM_DMABASE_CCMR3
#define TIM_DMABase_CCR5 TIM_DMABASE_CCR5
#define TIM_DMABase_CCR6 TIM_DMABASE_CCR6
#define TIM_DMABase_OR2 TIM_DMABASE_OR2
#define TIM_DMABase_OR3 TIM_DMABASE_OR3
#define TIM_DMABase_OR TIM_DMABASE_OR
#define TIM_EventSource_Update TIM_EVENTSOURCE_UPDATE
#define TIM_EventSource_CC1 TIM_EVENTSOURCE_CC1
#define TIM_EventSource_CC2 TIM_EVENTSOURCE_CC2
#define TIM_EventSource_CC3 TIM_EVENTSOURCE_CC3
#define TIM_EventSource_CC4 TIM_EVENTSOURCE_CC4
#define TIM_EventSource_COM TIM_EVENTSOURCE_COM
#define TIM_EventSource_Trigger TIM_EVENTSOURCE_TRIGGER
#define TIM_EventSource_Break TIM_EVENTSOURCE_BREAK
#define TIM_EventSource_Break2 TIM_EVENTSOURCE_BREAK2
#define TIM_DMABurstLength_1Transfer TIM_DMABURSTLENGTH_1TRANSFER
#define TIM_DMABurstLength_2Transfers TIM_DMABURSTLENGTH_2TRANSFERS
#define TIM_DMABurstLength_3Transfers TIM_DMABURSTLENGTH_3TRANSFERS
#define TIM_DMABurstLength_4Transfers TIM_DMABURSTLENGTH_4TRANSFERS
#define TIM_DMABurstLength_5Transfers TIM_DMABURSTLENGTH_5TRANSFERS
#define TIM_DMABurstLength_6Transfers TIM_DMABURSTLENGTH_6TRANSFERS
#define TIM_DMABurstLength_7Transfers TIM_DMABURSTLENGTH_7TRANSFERS
#define TIM_DMABurstLength_8Transfers TIM_DMABURSTLENGTH_8TRANSFERS
#define TIM_DMABurstLength_9Transfers TIM_DMABURSTLENGTH_9TRANSFERS
#define TIM_DMABurstLength_10Transfers TIM_DMABURSTLENGTH_10TRANSFERS
#define TIM_DMABurstLength_11Transfers TIM_DMABURSTLENGTH_11TRANSFERS
#define TIM_DMABurstLength_12Transfers TIM_DMABURSTLENGTH_12TRANSFERS
#define TIM_DMABurstLength_13Transfers TIM_DMABURSTLENGTH_13TRANSFERS
#define TIM_DMABurstLength_14Transfers TIM_DMABURSTLENGTH_14TRANSFERS
#define TIM_DMABurstLength_15Transfers TIM_DMABURSTLENGTH_15TRANSFERS
#define TIM_DMABurstLength_16Transfers TIM_DMABURSTLENGTH_16TRANSFERS
#define TIM_DMABurstLength_17Transfers TIM_DMABURSTLENGTH_17TRANSFERS
#define TIM_DMABurstLength_18Transfers TIM_DMABURSTLENGTH_18TRANSFERS
/**
* @}
*/
/** @defgroup HAL_TSC_Aliased_Defines HAL TSC Aliased Defines maintained for legacy purpose
* @{
*/
#define TSC_SYNC_POL_FALL TSC_SYNC_POLARITY_FALLING
#define TSC_SYNC_POL_RISE_HIGH TSC_SYNC_POLARITY_RISING
/**
* @}
*/
/** @defgroup HAL_UART_Aliased_Defines HAL UART Aliased Defines maintained for legacy purpose
* @{
*/
#define UART_ONEBIT_SAMPLING_DISABLED UART_ONE_BIT_SAMPLE_DISABLE
#define UART_ONEBIT_SAMPLING_ENABLED UART_ONE_BIT_SAMPLE_ENABLE
#define UART_ONE_BIT_SAMPLE_DISABLED UART_ONE_BIT_SAMPLE_DISABLE
#define UART_ONE_BIT_SAMPLE_ENABLED UART_ONE_BIT_SAMPLE_ENABLE
#define __HAL_UART_ONEBIT_ENABLE __HAL_UART_ONE_BIT_SAMPLE_ENABLE
#define __HAL_UART_ONEBIT_DISABLE __HAL_UART_ONE_BIT_SAMPLE_DISABLE
#define __DIV_SAMPLING16 UART_DIV_SAMPLING16
#define __DIVMANT_SAMPLING16 UART_DIVMANT_SAMPLING16
#define __DIVFRAQ_SAMPLING16 UART_DIVFRAQ_SAMPLING16
#define __UART_BRR_SAMPLING16 UART_BRR_SAMPLING16
#define __DIV_SAMPLING8 UART_DIV_SAMPLING8
#define __DIVMANT_SAMPLING8 UART_DIVMANT_SAMPLING8
#define __DIVFRAQ_SAMPLING8 UART_DIVFRAQ_SAMPLING8
#define __UART_BRR_SAMPLING8 UART_BRR_SAMPLING8
#define __DIV_LPUART UART_DIV_LPUART
#define UART_WAKEUPMETHODE_IDLELINE UART_WAKEUPMETHOD_IDLELINE
#define UART_WAKEUPMETHODE_ADDRESSMARK UART_WAKEUPMETHOD_ADDRESSMARK
/**
* @}
*/
/** @defgroup HAL_USART_Aliased_Defines HAL USART Aliased Defines maintained for legacy purpose
* @{
*/
#define USART_CLOCK_DISABLED USART_CLOCK_DISABLE
#define USART_CLOCK_ENABLED USART_CLOCK_ENABLE
#define USARTNACK_ENABLED USART_NACK_ENABLE
#define USARTNACK_DISABLED USART_NACK_DISABLE
/**
* @}
*/
/** @defgroup HAL_WWDG_Aliased_Defines HAL WWDG Aliased Defines maintained for legacy purpose
* @{
*/
#define CFR_BASE WWDG_CFR_BASE
/**
* @}
*/
/** @defgroup HAL_CAN_Aliased_Defines HAL CAN Aliased Defines maintained for legacy purpose
* @{
*/
#define CAN_FilterFIFO0 CAN_FILTER_FIFO0
#define CAN_FilterFIFO1 CAN_FILTER_FIFO1
#define CAN_IT_RQCP0 CAN_IT_TME
#define CAN_IT_RQCP1 CAN_IT_TME
#define CAN_IT_RQCP2 CAN_IT_TME
#define INAK_TIMEOUT CAN_TIMEOUT_VALUE
#define SLAK_TIMEOUT CAN_TIMEOUT_VALUE
#define CAN_TXSTATUS_FAILED ((uint8_t)0x00U)
#define CAN_TXSTATUS_OK ((uint8_t)0x01U)
#define CAN_TXSTATUS_PENDING ((uint8_t)0x02U)
/**
* @}
*/
/** @defgroup HAL_ETH_Aliased_Defines HAL ETH Aliased Defines maintained for legacy purpose
* @{
*/
#define VLAN_TAG ETH_VLAN_TAG
#define MIN_ETH_PAYLOAD ETH_MIN_ETH_PAYLOAD
#define MAX_ETH_PAYLOAD ETH_MAX_ETH_PAYLOAD
#define JUMBO_FRAME_PAYLOAD ETH_JUMBO_FRAME_PAYLOAD
#define MACMIIAR_CR_MASK ETH_MACMIIAR_CR_MASK
#define MACCR_CLEAR_MASK ETH_MACCR_CLEAR_MASK
#define MACFCR_CLEAR_MASK ETH_MACFCR_CLEAR_MASK
#define DMAOMR_CLEAR_MASK ETH_DMAOMR_CLEAR_MASK
#define ETH_MMCCR ((uint32_t)0x00000100U)
#define ETH_MMCRIR ((uint32_t)0x00000104U)
#define ETH_MMCTIR ((uint32_t)0x00000108U)
#define ETH_MMCRIMR ((uint32_t)0x0000010CU)
#define ETH_MMCTIMR ((uint32_t)0x00000110U)
#define ETH_MMCTGFSCCR ((uint32_t)0x0000014CU)
#define ETH_MMCTGFMSCCR ((uint32_t)0x00000150U)
#define ETH_MMCTGFCR ((uint32_t)0x00000168U)
#define ETH_MMCRFCECR ((uint32_t)0x00000194U)
#define ETH_MMCRFAECR ((uint32_t)0x00000198U)
#define ETH_MMCRGUFCR ((uint32_t)0x000001C4U)
#define ETH_MAC_TXFIFO_FULL ((uint32_t)0x02000000) /* Tx FIFO full */
#define ETH_MAC_TXFIFONOT_EMPTY ((uint32_t)0x01000000) /* Tx FIFO not empty */
#define ETH_MAC_TXFIFO_WRITE_ACTIVE ((uint32_t)0x00400000) /* Tx FIFO write active */
#define ETH_MAC_TXFIFO_IDLE ((uint32_t)0x00000000) /* Tx FIFO read status: Idle */
#define ETH_MAC_TXFIFO_READ ((uint32_t)0x00100000) /* Tx FIFO read status: Read (transferring data to the MAC transmitter) */
#define ETH_MAC_TXFIFO_WAITING ((uint32_t)0x00200000) /* Tx FIFO read status: Waiting for TxStatus from MAC transmitter */
#define ETH_MAC_TXFIFO_WRITING ((uint32_t)0x00300000) /* Tx FIFO read status: Writing the received TxStatus or flushing the TxFIFO */
#define ETH_MAC_TRANSMISSION_PAUSE ((uint32_t)0x00080000) /* MAC transmitter in pause */
#define ETH_MAC_TRANSMITFRAMECONTROLLER_IDLE ((uint32_t)0x00000000) /* MAC transmit frame controller: Idle */
#define ETH_MAC_TRANSMITFRAMECONTROLLER_WAITING ((uint32_t)0x00020000) /* MAC transmit frame controller: Waiting for Status of previous frame or IFG/backoff period to be over */
#define ETH_MAC_TRANSMITFRAMECONTROLLER_GENRATING_PCF ((uint32_t)0x00040000) /* MAC transmit frame controller: Generating and transmitting a Pause control frame (in full duplex mode) */
#define ETH_MAC_TRANSMITFRAMECONTROLLER_TRANSFERRING ((uint32_t)0x00060000) /* MAC transmit frame controller: Transferring input frame for transmission */
#define ETH_MAC_MII_TRANSMIT_ACTIVE ((uint32_t)0x00010000) /* MAC MII transmit engine active */
#define ETH_MAC_RXFIFO_EMPTY ((uint32_t)0x00000000) /* Rx FIFO fill level: empty */
#define ETH_MAC_RXFIFO_BELOW_THRESHOLD ((uint32_t)0x00000100) /* Rx FIFO fill level: fill-level below flow-control de-activate threshold */
#define ETH_MAC_RXFIFO_ABOVE_THRESHOLD ((uint32_t)0x00000200) /* Rx FIFO fill level: fill-level above flow-control activate threshold */
#define ETH_MAC_RXFIFO_FULL ((uint32_t)0x00000300) /* Rx FIFO fill level: full */
#if defined(STM32F1)
#else
#define ETH_MAC_READCONTROLLER_IDLE ((uint32_t)0x00000000) /* Rx FIFO read controller IDLE state */
#define ETH_MAC_READCONTROLLER_READING_DATA ((uint32_t)0x00000020) /* Rx FIFO read controller Reading frame data */
#define ETH_MAC_READCONTROLLER_READING_STATUS ((uint32_t)0x00000040) /* Rx FIFO read controller Reading frame status (or time-stamp) */
#endif
#define ETH_MAC_READCONTROLLER_FLUSHING ((uint32_t)0x00000060) /* Rx FIFO read controller Flushing the frame data and status */
#define ETH_MAC_RXFIFO_WRITE_ACTIVE ((uint32_t)0x00000010) /* Rx FIFO write controller active */
#define ETH_MAC_SMALL_FIFO_NOTACTIVE ((uint32_t)0x00000000) /* MAC small FIFO read / write controllers not active */
#define ETH_MAC_SMALL_FIFO_READ_ACTIVE ((uint32_t)0x00000002) /* MAC small FIFO read controller active */
#define ETH_MAC_SMALL_FIFO_WRITE_ACTIVE ((uint32_t)0x00000004) /* MAC small FIFO write controller active */
#define ETH_MAC_SMALL_FIFO_RW_ACTIVE ((uint32_t)0x00000006) /* MAC small FIFO read / write controllers active */
#define ETH_MAC_MII_RECEIVE_PROTOCOL_ACTIVE ((uint32_t)0x00000001) /* MAC MII receive protocol engine active */
/**
* @}
*/
/** @defgroup HAL_DCMI_Aliased_Defines HAL DCMI Aliased Defines maintained for legacy purpose
* @{
*/
#define HAL_DCMI_ERROR_OVF HAL_DCMI_ERROR_OVR
#define DCMI_IT_OVF DCMI_IT_OVR
#define DCMI_FLAG_OVFRI DCMI_FLAG_OVRRI
#define DCMI_FLAG_OVFMI DCMI_FLAG_OVRMI
#define HAL_DCMI_ConfigCROP HAL_DCMI_ConfigCrop
#define HAL_DCMI_EnableCROP HAL_DCMI_EnableCrop
#define HAL_DCMI_DisableCROP HAL_DCMI_DisableCrop
/**
* @}
*/
#if defined(STM32L4xx) || defined(STM32F7) || defined(STM32F427xx) || defined(STM32F437xx) ||\
defined(STM32F429xx) || defined(STM32F439xx) || defined(STM32F469xx) || defined(STM32F479xx)
/** @defgroup HAL_DMA2D_Aliased_Defines HAL DMA2D Aliased Defines maintained for legacy purpose
* @{
*/
#define DMA2D_ARGB8888 DMA2D_OUTPUT_ARGB8888
#define DMA2D_RGB888 DMA2D_OUTPUT_RGB888
#define DMA2D_RGB565 DMA2D_OUTPUT_RGB565
#define DMA2D_ARGB1555 DMA2D_OUTPUT_ARGB1555
#define DMA2D_ARGB4444 DMA2D_OUTPUT_ARGB4444
#define CM_ARGB8888 DMA2D_INPUT_ARGB8888
#define CM_RGB888 DMA2D_INPUT_RGB888
#define CM_RGB565 DMA2D_INPUT_RGB565
#define CM_ARGB1555 DMA2D_INPUT_ARGB1555
#define CM_ARGB4444 DMA2D_INPUT_ARGB4444
#define CM_L8 DMA2D_INPUT_L8
#define CM_AL44 DMA2D_INPUT_AL44
#define CM_AL88 DMA2D_INPUT_AL88
#define CM_L4 DMA2D_INPUT_L4
#define CM_A8 DMA2D_INPUT_A8
#define CM_A4 DMA2D_INPUT_A4
/**
* @}
*/
#endif /* STM32L4xx || STM32F7*/
/** @defgroup HAL_PPP_Aliased_Defines HAL PPP Aliased Defines maintained for legacy purpose
* @{
*/
/**
* @}
*/
/* Exported functions --------------------------------------------------------*/
/** @defgroup HAL_CRYP_Aliased_Functions HAL CRYP Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_CRYP_ComputationCpltCallback HAL_CRYPEx_ComputationCpltCallback
/**
* @}
*/
/** @defgroup HAL_HASH_Aliased_Functions HAL HASH Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_HASH_STATETypeDef HAL_HASH_StateTypeDef
#define HAL_HASHPhaseTypeDef HAL_HASH_PhaseTypeDef
#define HAL_HMAC_MD5_Finish HAL_HASH_MD5_Finish
#define HAL_HMAC_SHA1_Finish HAL_HASH_SHA1_Finish
#define HAL_HMAC_SHA224_Finish HAL_HASH_SHA224_Finish
#define HAL_HMAC_SHA256_Finish HAL_HASH_SHA256_Finish
/*HASH Algorithm Selection*/
#define HASH_AlgoSelection_SHA1 HASH_ALGOSELECTION_SHA1
#define HASH_AlgoSelection_SHA224 HASH_ALGOSELECTION_SHA224
#define HASH_AlgoSelection_SHA256 HASH_ALGOSELECTION_SHA256
#define HASH_AlgoSelection_MD5 HASH_ALGOSELECTION_MD5
#define HASH_AlgoMode_HASH HASH_ALGOMODE_HASH
#define HASH_AlgoMode_HMAC HASH_ALGOMODE_HMAC
#define HASH_HMACKeyType_ShortKey HASH_HMAC_KEYTYPE_SHORTKEY
#define HASH_HMACKeyType_LongKey HASH_HMAC_KEYTYPE_LONGKEY
/**
* @}
*/
/** @defgroup HAL_Aliased_Functions HAL Generic Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_EnableDBGSleepMode HAL_DBGMCU_EnableDBGSleepMode
#define HAL_DisableDBGSleepMode HAL_DBGMCU_DisableDBGSleepMode
#define HAL_EnableDBGStopMode HAL_DBGMCU_EnableDBGStopMode
#define HAL_DisableDBGStopMode HAL_DBGMCU_DisableDBGStopMode
#define HAL_EnableDBGStandbyMode HAL_DBGMCU_EnableDBGStandbyMode
#define HAL_DisableDBGStandbyMode HAL_DBGMCU_DisableDBGStandbyMode
#define HAL_DBG_LowPowerConfig(Periph, cmd) (((cmd)==ENABLE)? HAL_DBGMCU_DBG_EnableLowPowerConfig(Periph) : HAL_DBGMCU_DBG_DisableLowPowerConfig(Periph))
#define HAL_VREFINT_OutputSelect HAL_SYSCFG_VREFINT_OutputSelect
#define HAL_Lock_Cmd(cmd) (((cmd)==ENABLE) ? HAL_SYSCFG_Enable_Lock_VREFINT() : HAL_SYSCFG_Disable_Lock_VREFINT())
#if defined(STM32L0)
#else
#define HAL_VREFINT_Cmd(cmd) (((cmd)==ENABLE)? HAL_SYSCFG_EnableVREFINT() : HAL_SYSCFG_DisableVREFINT())
#endif
#define HAL_ADC_EnableBuffer_Cmd(cmd) (((cmd)==ENABLE) ? HAL_ADCEx_EnableVREFINT() : HAL_ADCEx_DisableVREFINT())
#define HAL_ADC_EnableBufferSensor_Cmd(cmd) (((cmd)==ENABLE) ? HAL_ADCEx_EnableVREFINTTempSensor() : HAL_ADCEx_DisableVREFINTTempSensor())
/**
* @}
*/
/** @defgroup HAL_FLASH_Aliased_Functions HAL FLASH Aliased Functions maintained for legacy purpose
* @{
*/
#define FLASH_HalfPageProgram HAL_FLASHEx_HalfPageProgram
#define FLASH_EnableRunPowerDown HAL_FLASHEx_EnableRunPowerDown
#define FLASH_DisableRunPowerDown HAL_FLASHEx_DisableRunPowerDown
#define HAL_DATA_EEPROMEx_Unlock HAL_FLASHEx_DATAEEPROM_Unlock
#define HAL_DATA_EEPROMEx_Lock HAL_FLASHEx_DATAEEPROM_Lock
#define HAL_DATA_EEPROMEx_Erase HAL_FLASHEx_DATAEEPROM_Erase
#define HAL_DATA_EEPROMEx_Program HAL_FLASHEx_DATAEEPROM_Program
/**
* @}
*/
/** @defgroup HAL_I2C_Aliased_Functions HAL I2C Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_I2CEx_AnalogFilter_Config HAL_I2CEx_ConfigAnalogFilter
#define HAL_I2CEx_DigitalFilter_Config HAL_I2CEx_ConfigDigitalFilter
#define HAL_FMPI2CEx_AnalogFilter_Config HAL_FMPI2CEx_ConfigAnalogFilter
#define HAL_FMPI2CEx_DigitalFilter_Config HAL_FMPI2CEx_ConfigDigitalFilter
#define HAL_I2CFastModePlusConfig(SYSCFG_I2CFastModePlus, cmd) (((cmd)==ENABLE)? HAL_I2CEx_EnableFastModePlus(SYSCFG_I2CFastModePlus): HAL_I2CEx_DisableFastModePlus(SYSCFG_I2CFastModePlus))
/**
* @}
*/
/** @defgroup HAL_PWR_Aliased HAL PWR Aliased maintained for legacy purpose
* @{
*/
#define HAL_PWR_PVDConfig HAL_PWR_ConfigPVD
#define HAL_PWR_DisableBkUpReg HAL_PWREx_DisableBkUpReg
#define HAL_PWR_DisableFlashPowerDown HAL_PWREx_DisableFlashPowerDown
#define HAL_PWR_DisableVddio2Monitor HAL_PWREx_DisableVddio2Monitor
#define HAL_PWR_EnableBkUpReg HAL_PWREx_EnableBkUpReg
#define HAL_PWR_EnableFlashPowerDown HAL_PWREx_EnableFlashPowerDown
#define HAL_PWR_EnableVddio2Monitor HAL_PWREx_EnableVddio2Monitor
#define HAL_PWR_PVD_PVM_IRQHandler HAL_PWREx_PVD_PVM_IRQHandler
#define HAL_PWR_PVDLevelConfig HAL_PWR_ConfigPVD
#define HAL_PWR_Vddio2Monitor_IRQHandler HAL_PWREx_Vddio2Monitor_IRQHandler
#define HAL_PWR_Vddio2MonitorCallback HAL_PWREx_Vddio2MonitorCallback
#define HAL_PWREx_ActivateOverDrive HAL_PWREx_EnableOverDrive
#define HAL_PWREx_DeactivateOverDrive HAL_PWREx_DisableOverDrive
#define HAL_PWREx_DisableSDADCAnalog HAL_PWREx_DisableSDADC
#define HAL_PWREx_EnableSDADCAnalog HAL_PWREx_EnableSDADC
#define HAL_PWREx_PVMConfig HAL_PWREx_ConfigPVM
#define PWR_MODE_NORMAL PWR_PVD_MODE_NORMAL
#define PWR_MODE_IT_RISING PWR_PVD_MODE_IT_RISING
#define PWR_MODE_IT_FALLING PWR_PVD_MODE_IT_FALLING
#define PWR_MODE_IT_RISING_FALLING PWR_PVD_MODE_IT_RISING_FALLING
#define PWR_MODE_EVENT_RISING PWR_PVD_MODE_EVENT_RISING
#define PWR_MODE_EVENT_FALLING PWR_PVD_MODE_EVENT_FALLING
#define PWR_MODE_EVENT_RISING_FALLING PWR_PVD_MODE_EVENT_RISING_FALLING
#define CR_OFFSET_BB PWR_CR_OFFSET_BB
#define CSR_OFFSET_BB PWR_CSR_OFFSET_BB
#define DBP_BitNumber DBP_BIT_NUMBER
#define PVDE_BitNumber PVDE_BIT_NUMBER
#define PMODE_BitNumber PMODE_BIT_NUMBER
#define EWUP_BitNumber EWUP_BIT_NUMBER
#define FPDS_BitNumber FPDS_BIT_NUMBER
#define ODEN_BitNumber ODEN_BIT_NUMBER
#define ODSWEN_BitNumber ODSWEN_BIT_NUMBER
#define MRLVDS_BitNumber MRLVDS_BIT_NUMBER
#define LPLVDS_BitNumber LPLVDS_BIT_NUMBER
#define BRE_BitNumber BRE_BIT_NUMBER
#define PWR_MODE_EVT PWR_PVD_MODE_NORMAL
/**
* @}
*/
/** @defgroup HAL_SMBUS_Aliased_Functions HAL SMBUS Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_SMBUS_Slave_Listen_IT HAL_SMBUS_EnableListen_IT
#define HAL_SMBUS_SlaveAddrCallback HAL_SMBUS_AddrCallback
#define HAL_SMBUS_SlaveListenCpltCallback HAL_SMBUS_ListenCpltCallback
/**
* @}
*/
/** @defgroup HAL_SPI_Aliased_Functions HAL SPI Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_SPI_FlushRxFifo HAL_SPIEx_FlushRxFifo
/**
* @}
*/
/** @defgroup HAL_TIM_Aliased_Functions HAL TIM Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_TIM_DMADelayPulseCplt TIM_DMADelayPulseCplt
#define HAL_TIM_DMAError TIM_DMAError
#define HAL_TIM_DMACaptureCplt TIM_DMACaptureCplt
#define HAL_TIMEx_DMACommutationCplt TIMEx_DMACommutationCplt
/**
* @}
*/
/** @defgroup HAL_UART_Aliased_Functions HAL UART Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_UART_WakeupCallback HAL_UARTEx_WakeupCallback
/**
* @}
*/
/** @defgroup HAL_LTDC_Aliased_Functions HAL LTDC Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_LTDC_LineEvenCallback HAL_LTDC_LineEventCallback
/**
* @}
*/
/** @defgroup HAL_PPP_Aliased_Functions HAL PPP Aliased Functions maintained for legacy purpose
* @{
*/
/**
* @}
*/
/* Exported macros ------------------------------------------------------------*/
/** @defgroup HAL_AES_Aliased_Macros HAL CRYP Aliased Macros maintained for legacy purpose
* @{
*/
#define AES_IT_CC CRYP_IT_CC
#define AES_IT_ERR CRYP_IT_ERR
#define AES_FLAG_CCF CRYP_FLAG_CCF
/**
* @}
*/
/** @defgroup HAL_Aliased_Macros HAL Generic Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_GET_BOOT_MODE __HAL_SYSCFG_GET_BOOT_MODE
#define __HAL_REMAPMEMORY_FLASH __HAL_SYSCFG_REMAPMEMORY_FLASH
#define __HAL_REMAPMEMORY_SYSTEMFLASH __HAL_SYSCFG_REMAPMEMORY_SYSTEMFLASH
#define __HAL_REMAPMEMORY_SRAM __HAL_SYSCFG_REMAPMEMORY_SRAM
#define __HAL_REMAPMEMORY_FMC __HAL_SYSCFG_REMAPMEMORY_FMC
#define __HAL_REMAPMEMORY_FMC_SDRAM __HAL_SYSCFG_REMAPMEMORY_FMC_SDRAM
#define __HAL_REMAPMEMORY_FSMC __HAL_SYSCFG_REMAPMEMORY_FSMC
#define __HAL_REMAPMEMORY_QUADSPI __HAL_SYSCFG_REMAPMEMORY_QUADSPI
#define __HAL_FMC_BANK __HAL_SYSCFG_FMC_BANK
#define __HAL_GET_FLAG __HAL_SYSCFG_GET_FLAG
#define __HAL_CLEAR_FLAG __HAL_SYSCFG_CLEAR_FLAG
#define __HAL_VREFINT_OUT_ENABLE __HAL_SYSCFG_VREFINT_OUT_ENABLE
#define __HAL_VREFINT_OUT_DISABLE __HAL_SYSCFG_VREFINT_OUT_DISABLE
#define SYSCFG_FLAG_VREF_READY SYSCFG_FLAG_VREFINT_READY
#define SYSCFG_FLAG_RC48 RCC_FLAG_HSI48
#define IS_SYSCFG_FASTMODEPLUS_CONFIG IS_I2C_FASTMODEPLUS
#define UFB_MODE_BitNumber UFB_MODE_BIT_NUMBER
#define CMP_PD_BitNumber CMP_PD_BIT_NUMBER
/**
* @}
*/
/** @defgroup HAL_ADC_Aliased_Macros HAL ADC Aliased Macros maintained for legacy purpose
* @{
*/
#define __ADC_ENABLE __HAL_ADC_ENABLE
#define __ADC_DISABLE __HAL_ADC_DISABLE
#define __HAL_ADC_ENABLING_CONDITIONS ADC_ENABLING_CONDITIONS
#define __HAL_ADC_DISABLING_CONDITIONS ADC_DISABLING_CONDITIONS
#define __HAL_ADC_IS_ENABLED ADC_IS_ENABLE
#define __ADC_IS_ENABLED ADC_IS_ENABLE
#define __HAL_ADC_IS_SOFTWARE_START_REGULAR ADC_IS_SOFTWARE_START_REGULAR
#define __HAL_ADC_IS_SOFTWARE_START_INJECTED ADC_IS_SOFTWARE_START_INJECTED
#define __HAL_ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED
#define __HAL_ADC_IS_CONVERSION_ONGOING_REGULAR ADC_IS_CONVERSION_ONGOING_REGULAR
#define __HAL_ADC_IS_CONVERSION_ONGOING_INJECTED ADC_IS_CONVERSION_ONGOING_INJECTED
#define __HAL_ADC_IS_CONVERSION_ONGOING ADC_IS_CONVERSION_ONGOING
#define __HAL_ADC_CLEAR_ERRORCODE ADC_CLEAR_ERRORCODE
#define __HAL_ADC_GET_RESOLUTION ADC_GET_RESOLUTION
#define __HAL_ADC_JSQR_RK ADC_JSQR_RK
#define __HAL_ADC_CFGR_AWD1CH ADC_CFGR_AWD1CH_SHIFT
#define __HAL_ADC_CFGR_AWD23CR ADC_CFGR_AWD23CR
#define __HAL_ADC_CFGR_INJECT_AUTO_CONVERSION ADC_CFGR_INJECT_AUTO_CONVERSION
#define __HAL_ADC_CFGR_INJECT_CONTEXT_QUEUE ADC_CFGR_INJECT_CONTEXT_QUEUE
#define __HAL_ADC_CFGR_INJECT_DISCCONTINUOUS ADC_CFGR_INJECT_DISCCONTINUOUS
#define __HAL_ADC_CFGR_REG_DISCCONTINUOUS ADC_CFGR_REG_DISCCONTINUOUS
#define __HAL_ADC_CFGR_DISCONTINUOUS_NUM ADC_CFGR_DISCONTINUOUS_NUM
#define __HAL_ADC_CFGR_AUTOWAIT ADC_CFGR_AUTOWAIT
#define __HAL_ADC_CFGR_CONTINUOUS ADC_CFGR_CONTINUOUS
#define __HAL_ADC_CFGR_OVERRUN ADC_CFGR_OVERRUN
#define __HAL_ADC_CFGR_DMACONTREQ ADC_CFGR_DMACONTREQ
#define __HAL_ADC_CFGR_EXTSEL ADC_CFGR_EXTSEL_SET
#define __HAL_ADC_JSQR_JEXTSEL ADC_JSQR_JEXTSEL_SET
#define __HAL_ADC_OFR_CHANNEL ADC_OFR_CHANNEL
#define __HAL_ADC_DIFSEL_CHANNEL ADC_DIFSEL_CHANNEL
#define __HAL_ADC_CALFACT_DIFF_SET ADC_CALFACT_DIFF_SET
#define __HAL_ADC_CALFACT_DIFF_GET ADC_CALFACT_DIFF_GET
#define __HAL_ADC_TRX_HIGHTHRESHOLD ADC_TRX_HIGHTHRESHOLD
#define __HAL_ADC_OFFSET_SHIFT_RESOLUTION ADC_OFFSET_SHIFT_RESOLUTION
#define __HAL_ADC_AWD1THRESHOLD_SHIFT_RESOLUTION ADC_AWD1THRESHOLD_SHIFT_RESOLUTION
#define __HAL_ADC_AWD23THRESHOLD_SHIFT_RESOLUTION ADC_AWD23THRESHOLD_SHIFT_RESOLUTION
#define __HAL_ADC_COMMON_REGISTER ADC_COMMON_REGISTER
#define __HAL_ADC_COMMON_CCR_MULTI ADC_COMMON_CCR_MULTI
#define __HAL_ADC_MULTIMODE_IS_ENABLED ADC_MULTIMODE_IS_ENABLE
#define __ADC_MULTIMODE_IS_ENABLED ADC_MULTIMODE_IS_ENABLE
#define __HAL_ADC_NONMULTIMODE_OR_MULTIMODEMASTER ADC_NONMULTIMODE_OR_MULTIMODEMASTER
#define __HAL_ADC_COMMON_ADC_OTHER ADC_COMMON_ADC_OTHER
#define __HAL_ADC_MULTI_SLAVE ADC_MULTI_SLAVE
#define __HAL_ADC_SQR1_L ADC_SQR1_L_SHIFT
#define __HAL_ADC_JSQR_JL ADC_JSQR_JL_SHIFT
#define __HAL_ADC_JSQR_RK_JL ADC_JSQR_RK_JL
#define __HAL_ADC_CR1_DISCONTINUOUS_NUM ADC_CR1_DISCONTINUOUS_NUM
#define __HAL_ADC_CR1_SCAN ADC_CR1_SCAN_SET
#define __HAL_ADC_CONVCYCLES_MAX_RANGE ADC_CONVCYCLES_MAX_RANGE
#define __HAL_ADC_CLOCK_PRESCALER_RANGE ADC_CLOCK_PRESCALER_RANGE
#define __HAL_ADC_GET_CLOCK_PRESCALER ADC_GET_CLOCK_PRESCALER
#define __HAL_ADC_SQR1 ADC_SQR1
#define __HAL_ADC_SMPR1 ADC_SMPR1
#define __HAL_ADC_SMPR2 ADC_SMPR2
#define __HAL_ADC_SQR3_RK ADC_SQR3_RK
#define __HAL_ADC_SQR2_RK ADC_SQR2_RK
#define __HAL_ADC_SQR1_RK ADC_SQR1_RK
#define __HAL_ADC_CR2_CONTINUOUS ADC_CR2_CONTINUOUS
#define __HAL_ADC_CR1_DISCONTINUOUS ADC_CR1_DISCONTINUOUS
#define __HAL_ADC_CR1_SCANCONV ADC_CR1_SCANCONV
#define __HAL_ADC_CR2_EOCSelection ADC_CR2_EOCSelection
#define __HAL_ADC_CR2_DMAContReq ADC_CR2_DMAContReq
#define __HAL_ADC_JSQR ADC_JSQR
#define __HAL_ADC_CHSELR_CHANNEL ADC_CHSELR_CHANNEL
#define __HAL_ADC_CFGR1_REG_DISCCONTINUOUS ADC_CFGR1_REG_DISCCONTINUOUS
#define __HAL_ADC_CFGR1_AUTOOFF ADC_CFGR1_AUTOOFF
#define __HAL_ADC_CFGR1_AUTOWAIT ADC_CFGR1_AUTOWAIT
#define __HAL_ADC_CFGR1_CONTINUOUS ADC_CFGR1_CONTINUOUS
#define __HAL_ADC_CFGR1_OVERRUN ADC_CFGR1_OVERRUN
#define __HAL_ADC_CFGR1_SCANDIR ADC_CFGR1_SCANDIR
#define __HAL_ADC_CFGR1_DMACONTREQ ADC_CFGR1_DMACONTREQ
/**
* @}
*/
/** @defgroup HAL_DAC_Aliased_Macros HAL DAC Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_DHR12R1_ALIGNEMENT DAC_DHR12R1_ALIGNMENT
#define __HAL_DHR12R2_ALIGNEMENT DAC_DHR12R2_ALIGNMENT
#define __HAL_DHR12RD_ALIGNEMENT DAC_DHR12RD_ALIGNMENT
#define IS_DAC_GENERATE_WAVE IS_DAC_WAVE
/**
* @}
*/
/** @defgroup HAL_DBGMCU_Aliased_Macros HAL DBGMCU Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_FREEZE_TIM1_DBGMCU __HAL_DBGMCU_FREEZE_TIM1
#define __HAL_UNFREEZE_TIM1_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM1
#define __HAL_FREEZE_TIM2_DBGMCU __HAL_DBGMCU_FREEZE_TIM2
#define __HAL_UNFREEZE_TIM2_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM2
#define __HAL_FREEZE_TIM3_DBGMCU __HAL_DBGMCU_FREEZE_TIM3
#define __HAL_UNFREEZE_TIM3_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM3
#define __HAL_FREEZE_TIM4_DBGMCU __HAL_DBGMCU_FREEZE_TIM4
#define __HAL_UNFREEZE_TIM4_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM4
#define __HAL_FREEZE_TIM5_DBGMCU __HAL_DBGMCU_FREEZE_TIM5
#define __HAL_UNFREEZE_TIM5_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM5
#define __HAL_FREEZE_TIM6_DBGMCU __HAL_DBGMCU_FREEZE_TIM6
#define __HAL_UNFREEZE_TIM6_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM6
#define __HAL_FREEZE_TIM7_DBGMCU __HAL_DBGMCU_FREEZE_TIM7
#define __HAL_UNFREEZE_TIM7_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM7
#define __HAL_FREEZE_TIM8_DBGMCU __HAL_DBGMCU_FREEZE_TIM8
#define __HAL_UNFREEZE_TIM8_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM8
#define __HAL_FREEZE_TIM9_DBGMCU __HAL_DBGMCU_FREEZE_TIM9
#define __HAL_UNFREEZE_TIM9_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM9
#define __HAL_FREEZE_TIM10_DBGMCU __HAL_DBGMCU_FREEZE_TIM10
#define __HAL_UNFREEZE_TIM10_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM10
#define __HAL_FREEZE_TIM11_DBGMCU __HAL_DBGMCU_FREEZE_TIM11
#define __HAL_UNFREEZE_TIM11_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM11
#define __HAL_FREEZE_TIM12_DBGMCU __HAL_DBGMCU_FREEZE_TIM12
#define __HAL_UNFREEZE_TIM12_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM12
#define __HAL_FREEZE_TIM13_DBGMCU __HAL_DBGMCU_FREEZE_TIM13
#define __HAL_UNFREEZE_TIM13_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM13
#define __HAL_FREEZE_TIM14_DBGMCU __HAL_DBGMCU_FREEZE_TIM14
#define __HAL_UNFREEZE_TIM14_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM14
#define __HAL_FREEZE_CAN2_DBGMCU __HAL_DBGMCU_FREEZE_CAN2
#define __HAL_UNFREEZE_CAN2_DBGMCU __HAL_DBGMCU_UNFREEZE_CAN2
#define __HAL_FREEZE_TIM15_DBGMCU __HAL_DBGMCU_FREEZE_TIM15
#define __HAL_UNFREEZE_TIM15_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM15
#define __HAL_FREEZE_TIM16_DBGMCU __HAL_DBGMCU_FREEZE_TIM16
#define __HAL_UNFREEZE_TIM16_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM16
#define __HAL_FREEZE_TIM17_DBGMCU __HAL_DBGMCU_FREEZE_TIM17
#define __HAL_UNFREEZE_TIM17_DBGMCU __HAL_DBGMCU_UNFREEZE_TIM17
#define __HAL_FREEZE_RTC_DBGMCU __HAL_DBGMCU_FREEZE_RTC
#define __HAL_UNFREEZE_RTC_DBGMCU __HAL_DBGMCU_UNFREEZE_RTC
#define __HAL_FREEZE_WWDG_DBGMCU __HAL_DBGMCU_FREEZE_WWDG
#define __HAL_UNFREEZE_WWDG_DBGMCU __HAL_DBGMCU_UNFREEZE_WWDG
#define __HAL_FREEZE_IWDG_DBGMCU __HAL_DBGMCU_FREEZE_IWDG
#define __HAL_UNFREEZE_IWDG_DBGMCU __HAL_DBGMCU_UNFREEZE_IWDG
#define __HAL_FREEZE_I2C1_TIMEOUT_DBGMCU __HAL_DBGMCU_FREEZE_I2C1_TIMEOUT
#define __HAL_UNFREEZE_I2C1_TIMEOUT_DBGMCU __HAL_DBGMCU_UNFREEZE_I2C1_TIMEOUT
#define __HAL_FREEZE_I2C2_TIMEOUT_DBGMCU __HAL_DBGMCU_FREEZE_I2C2_TIMEOUT
#define __HAL_UNFREEZE_I2C2_TIMEOUT_DBGMCU __HAL_DBGMCU_UNFREEZE_I2C2_TIMEOUT
#define __HAL_FREEZE_I2C3_TIMEOUT_DBGMCU __HAL_DBGMCU_FREEZE_I2C3_TIMEOUT
#define __HAL_UNFREEZE_I2C3_TIMEOUT_DBGMCU __HAL_DBGMCU_UNFREEZE_I2C3_TIMEOUT
#define __HAL_FREEZE_CAN1_DBGMCU __HAL_DBGMCU_FREEZE_CAN1
#define __HAL_UNFREEZE_CAN1_DBGMCU __HAL_DBGMCU_UNFREEZE_CAN1
#define __HAL_FREEZE_LPTIM1_DBGMCU __HAL_DBGMCU_FREEZE_LPTIM1
#define __HAL_UNFREEZE_LPTIM1_DBGMCU __HAL_DBGMCU_UNFREEZE_LPTIM1
#define __HAL_FREEZE_LPTIM2_DBGMCU __HAL_DBGMCU_FREEZE_LPTIM2
#define __HAL_UNFREEZE_LPTIM2_DBGMCU __HAL_DBGMCU_UNFREEZE_LPTIM2
/**
* @}
*/
/** @defgroup HAL_COMP_Aliased_Macros HAL COMP Aliased Macros maintained for legacy purpose
* @{
*/
#if defined(STM32F3)
#define COMP_START __HAL_COMP_ENABLE
#define COMP_STOP __HAL_COMP_DISABLE
#define COMP_LOCK __HAL_COMP_LOCK
#if defined(STM32F301x8) || defined(STM32F302x8) || defined(STM32F318xx) || defined(STM32F303x8) || defined(STM32F334x8) || defined(STM32F328xx)
#define __HAL_COMP_EXTI_RISING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_RISING_EDGE() : \
__HAL_COMP_COMP6_EXTI_ENABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_RISING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_RISING_EDGE() : \
__HAL_COMP_COMP6_EXTI_DISABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_FALLING_EDGE() : \
__HAL_COMP_COMP6_EXTI_ENABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_FALLING_EDGE() : \
__HAL_COMP_COMP6_EXTI_DISABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_ENABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_IT() : \
__HAL_COMP_COMP6_EXTI_ENABLE_IT())
#define __HAL_COMP_EXTI_DISABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_IT() : \
__HAL_COMP_COMP6_EXTI_DISABLE_IT())
#define __HAL_COMP_EXTI_GET_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_GET_FLAG() : \
__HAL_COMP_COMP6_EXTI_GET_FLAG())
#define __HAL_COMP_EXTI_CLEAR_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_CLEAR_FLAG() : \
__HAL_COMP_COMP6_EXTI_CLEAR_FLAG())
# endif
# if defined(STM32F302xE) || defined(STM32F302xC)
#define __HAL_COMP_EXTI_RISING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_RISING_EDGE() : \
__HAL_COMP_COMP6_EXTI_ENABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_RISING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_RISING_EDGE() : \
__HAL_COMP_COMP6_EXTI_DISABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_FALLING_EDGE() : \
__HAL_COMP_COMP6_EXTI_ENABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_FALLING_EDGE() : \
__HAL_COMP_COMP6_EXTI_DISABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_ENABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_IT() : \
__HAL_COMP_COMP6_EXTI_ENABLE_IT())
#define __HAL_COMP_EXTI_DISABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_IT() : \
__HAL_COMP_COMP6_EXTI_DISABLE_IT())
#define __HAL_COMP_EXTI_GET_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_GET_FLAG() : \
__HAL_COMP_COMP6_EXTI_GET_FLAG())
#define __HAL_COMP_EXTI_CLEAR_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_CLEAR_FLAG() : \
__HAL_COMP_COMP6_EXTI_CLEAR_FLAG())
# endif
# if defined(STM32F303xE) || defined(STM32F398xx) || defined(STM32F303xC) || defined(STM32F358xx)
#define __HAL_COMP_EXTI_RISING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_ENABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_ENABLE_RISING_EDGE() : \
__HAL_COMP_COMP7_EXTI_ENABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_RISING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_DISABLE_RISING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_DISABLE_RISING_EDGE() : \
__HAL_COMP_COMP7_EXTI_DISABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_ENABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_ENABLE_FALLING_EDGE() : \
__HAL_COMP_COMP7_EXTI_ENABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_DISABLE_FALLING_EDGE() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_DISABLE_FALLING_EDGE() : \
__HAL_COMP_COMP7_EXTI_DISABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_ENABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_ENABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_ENABLE_IT() : \
__HAL_COMP_COMP7_EXTI_ENABLE_IT())
#define __HAL_COMP_EXTI_DISABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_DISABLE_IT() : \
((__EXTILINE__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_DISABLE_IT() : \
__HAL_COMP_COMP7_EXTI_DISABLE_IT())
#define __HAL_COMP_EXTI_GET_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_GET_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_GET_FLAG() : \
__HAL_COMP_COMP7_EXTI_GET_FLAG())
#define __HAL_COMP_EXTI_CLEAR_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP2) ? __HAL_COMP_COMP2_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP3) ? __HAL_COMP_COMP3_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP4) ? __HAL_COMP_COMP4_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP5) ? __HAL_COMP_COMP5_EXTI_CLEAR_FLAG() : \
((__FLAG__) == COMP_EXTI_LINE_COMP6) ? __HAL_COMP_COMP6_EXTI_CLEAR_FLAG() : \
__HAL_COMP_COMP7_EXTI_CLEAR_FLAG())
# endif
# if defined(STM32F373xC) ||defined(STM32F378xx)
#define __HAL_COMP_EXTI_RISING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_RISING_EDGE() : \
__HAL_COMP_COMP2_EXTI_ENABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_RISING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_RISING_EDGE() : \
__HAL_COMP_COMP2_EXTI_DISABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_FALLING_EDGE() : \
__HAL_COMP_COMP2_EXTI_ENABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_FALLING_EDGE() : \
__HAL_COMP_COMP2_EXTI_DISABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_ENABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_IT() : \
__HAL_COMP_COMP2_EXTI_ENABLE_IT())
#define __HAL_COMP_EXTI_DISABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_IT() : \
__HAL_COMP_COMP2_EXTI_DISABLE_IT())
#define __HAL_COMP_EXTI_GET_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_GET_FLAG() : \
__HAL_COMP_COMP2_EXTI_GET_FLAG())
#define __HAL_COMP_EXTI_CLEAR_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_CLEAR_FLAG() : \
__HAL_COMP_COMP2_EXTI_CLEAR_FLAG())
# endif
#else
#define __HAL_COMP_EXTI_RISING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_RISING_EDGE() : \
__HAL_COMP_COMP2_EXTI_ENABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_RISING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_RISING_EDGE() : \
__HAL_COMP_COMP2_EXTI_DISABLE_RISING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_ENABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_FALLING_EDGE() : \
__HAL_COMP_COMP2_EXTI_ENABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_FALLING_IT_DISABLE(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_FALLING_EDGE() : \
__HAL_COMP_COMP2_EXTI_DISABLE_FALLING_EDGE())
#define __HAL_COMP_EXTI_ENABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_ENABLE_IT() : \
__HAL_COMP_COMP2_EXTI_ENABLE_IT())
#define __HAL_COMP_EXTI_DISABLE_IT(__EXTILINE__) (((__EXTILINE__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_DISABLE_IT() : \
__HAL_COMP_COMP2_EXTI_DISABLE_IT())
#define __HAL_COMP_EXTI_GET_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_GET_FLAG() : \
__HAL_COMP_COMP2_EXTI_GET_FLAG())
#define __HAL_COMP_EXTI_CLEAR_FLAG(__FLAG__) (((__FLAG__) == COMP_EXTI_LINE_COMP1) ? __HAL_COMP_COMP1_EXTI_CLEAR_FLAG() : \
__HAL_COMP_COMP2_EXTI_CLEAR_FLAG())
#endif
#define __HAL_COMP_GET_EXTI_LINE COMP_GET_EXTI_LINE
#if defined(STM32L0) || defined(STM32L4)
/* Note: On these STM32 families, the only argument of this macro */
/* is COMP_FLAG_LOCK. */
/* This macro is replaced by __HAL_COMP_IS_LOCKED with only HAL handle */
/* argument. */
#define __HAL_COMP_GET_FLAG(__HANDLE__, __FLAG__) (__HAL_COMP_IS_LOCKED(__HANDLE__))
#endif
/**
* @}
*/
#if defined(STM32L0) || defined(STM32L4)
/** @defgroup HAL_COMP_Aliased_Functions HAL COMP Aliased Functions maintained for legacy purpose
* @{
*/
#define HAL_COMP_Start_IT HAL_COMP_Start /* Function considered as legacy as EXTI event or IT configuration is done into HAL_COMP_Init() */
#define HAL_COMP_Stop_IT HAL_COMP_Stop /* Function considered as legacy as EXTI event or IT configuration is done into HAL_COMP_Init() */
/**
* @}
*/
#endif
/** @defgroup HAL_DAC_Aliased_Macros HAL DAC Aliased Macros maintained for legacy purpose
* @{
*/
#define IS_DAC_WAVE(WAVE) (((WAVE) == DAC_WAVE_NONE) || \
((WAVE) == DAC_WAVE_NOISE)|| \
((WAVE) == DAC_WAVE_TRIANGLE))
/**
* @}
*/
/** @defgroup HAL_FLASH_Aliased_Macros HAL FLASH Aliased Macros maintained for legacy purpose
* @{
*/
#define IS_WRPAREA IS_OB_WRPAREA
#define IS_TYPEPROGRAM IS_FLASH_TYPEPROGRAM
#define IS_TYPEPROGRAMFLASH IS_FLASH_TYPEPROGRAM
#define IS_TYPEERASE IS_FLASH_TYPEERASE
#define IS_NBSECTORS IS_FLASH_NBSECTORS
#define IS_OB_WDG_SOURCE IS_OB_IWDG_SOURCE
/**
* @}
*/
/** @defgroup HAL_I2C_Aliased_Macros HAL I2C Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_I2C_RESET_CR2 I2C_RESET_CR2
#define __HAL_I2C_GENERATE_START I2C_GENERATE_START
#define __HAL_I2C_FREQ_RANGE I2C_FREQ_RANGE
#define __HAL_I2C_RISE_TIME I2C_RISE_TIME
#define __HAL_I2C_SPEED_STANDARD I2C_SPEED_STANDARD
#define __HAL_I2C_SPEED_FAST I2C_SPEED_FAST
#define __HAL_I2C_SPEED I2C_SPEED
#define __HAL_I2C_7BIT_ADD_WRITE I2C_7BIT_ADD_WRITE
#define __HAL_I2C_7BIT_ADD_READ I2C_7BIT_ADD_READ
#define __HAL_I2C_10BIT_ADDRESS I2C_10BIT_ADDRESS
#define __HAL_I2C_10BIT_HEADER_WRITE I2C_10BIT_HEADER_WRITE
#define __HAL_I2C_10BIT_HEADER_READ I2C_10BIT_HEADER_READ
#define __HAL_I2C_MEM_ADD_MSB I2C_MEM_ADD_MSB
#define __HAL_I2C_MEM_ADD_LSB I2C_MEM_ADD_LSB
#define __HAL_I2C_FREQRANGE I2C_FREQRANGE
/**
* @}
*/
/** @defgroup HAL_I2S_Aliased_Macros HAL I2S Aliased Macros maintained for legacy purpose
* @{
*/
#define IS_I2S_INSTANCE IS_I2S_ALL_INSTANCE
#define IS_I2S_INSTANCE_EXT IS_I2S_ALL_INSTANCE_EXT
/**
* @}
*/
/** @defgroup HAL_IRDA_Aliased_Macros HAL IRDA Aliased Macros maintained for legacy purpose
* @{
*/
#define __IRDA_DISABLE __HAL_IRDA_DISABLE
#define __IRDA_ENABLE __HAL_IRDA_ENABLE
#define __HAL_IRDA_GETCLOCKSOURCE IRDA_GETCLOCKSOURCE
#define __HAL_IRDA_MASK_COMPUTATION IRDA_MASK_COMPUTATION
#define __IRDA_GETCLOCKSOURCE IRDA_GETCLOCKSOURCE
#define __IRDA_MASK_COMPUTATION IRDA_MASK_COMPUTATION
#define IS_IRDA_ONEBIT_SAMPLE IS_IRDA_ONE_BIT_SAMPLE
/**
* @}
*/
/** @defgroup HAL_IWDG_Aliased_Macros HAL IWDG Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_IWDG_ENABLE_WRITE_ACCESS IWDG_ENABLE_WRITE_ACCESS
#define __HAL_IWDG_DISABLE_WRITE_ACCESS IWDG_DISABLE_WRITE_ACCESS
/**
* @}
*/
/** @defgroup HAL_LPTIM_Aliased_Macros HAL LPTIM Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_LPTIM_ENABLE_INTERRUPT __HAL_LPTIM_ENABLE_IT
#define __HAL_LPTIM_DISABLE_INTERRUPT __HAL_LPTIM_DISABLE_IT
#define __HAL_LPTIM_GET_ITSTATUS __HAL_LPTIM_GET_IT_SOURCE
/**
* @}
*/
/** @defgroup HAL_OPAMP_Aliased_Macros HAL OPAMP Aliased Macros maintained for legacy purpose
* @{
*/
#define __OPAMP_CSR_OPAXPD OPAMP_CSR_OPAXPD
#define __OPAMP_CSR_S3SELX OPAMP_CSR_S3SELX
#define __OPAMP_CSR_S4SELX OPAMP_CSR_S4SELX
#define __OPAMP_CSR_S5SELX OPAMP_CSR_S5SELX
#define __OPAMP_CSR_S6SELX OPAMP_CSR_S6SELX
#define __OPAMP_CSR_OPAXCAL_L OPAMP_CSR_OPAXCAL_L
#define __OPAMP_CSR_OPAXCAL_H OPAMP_CSR_OPAXCAL_H
#define __OPAMP_CSR_OPAXLPM OPAMP_CSR_OPAXLPM
#define __OPAMP_CSR_ALL_SWITCHES OPAMP_CSR_ALL_SWITCHES
#define __OPAMP_CSR_ANAWSELX OPAMP_CSR_ANAWSELX
#define __OPAMP_CSR_OPAXCALOUT OPAMP_CSR_OPAXCALOUT
#define __OPAMP_OFFSET_TRIM_BITSPOSITION OPAMP_OFFSET_TRIM_BITSPOSITION
#define __OPAMP_OFFSET_TRIM_SET OPAMP_OFFSET_TRIM_SET
/**
* @}
*/
/** @defgroup HAL_PWR_Aliased_Macros HAL PWR Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_PVD_EVENT_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_EVENT
#define __HAL_PVD_EVENT_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_EVENT
#define __HAL_PVD_EXTI_FALLINGTRIGGER_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_FALLING_EDGE
#define __HAL_PVD_EXTI_FALLINGTRIGGER_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_FALLING_EDGE
#define __HAL_PVD_EXTI_RISINGTRIGGER_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_RISING_EDGE
#define __HAL_PVD_EXTI_RISINGTRIGGER_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_RISING_EDGE
#define __HAL_PVM_EVENT_DISABLE __HAL_PWR_PVM_EVENT_DISABLE
#define __HAL_PVM_EVENT_ENABLE __HAL_PWR_PVM_EVENT_ENABLE
#define __HAL_PVM_EXTI_FALLINGTRIGGER_DISABLE __HAL_PWR_PVM_EXTI_FALLINGTRIGGER_DISABLE
#define __HAL_PVM_EXTI_FALLINGTRIGGER_ENABLE __HAL_PWR_PVM_EXTI_FALLINGTRIGGER_ENABLE
#define __HAL_PVM_EXTI_RISINGTRIGGER_DISABLE __HAL_PWR_PVM_EXTI_RISINGTRIGGER_DISABLE
#define __HAL_PVM_EXTI_RISINGTRIGGER_ENABLE __HAL_PWR_PVM_EXTI_RISINGTRIGGER_ENABLE
#define __HAL_PWR_INTERNALWAKEUP_DISABLE HAL_PWREx_DisableInternalWakeUpLine
#define __HAL_PWR_INTERNALWAKEUP_ENABLE HAL_PWREx_EnableInternalWakeUpLine
#define __HAL_PWR_PULL_UP_DOWN_CONFIG_DISABLE HAL_PWREx_DisablePullUpPullDownConfig
#define __HAL_PWR_PULL_UP_DOWN_CONFIG_ENABLE HAL_PWREx_EnablePullUpPullDownConfig
#define __HAL_PWR_PVD_EXTI_CLEAR_EGDE_TRIGGER() do { __HAL_PWR_PVD_EXTI_DISABLE_RISING_EDGE();__HAL_PWR_PVD_EXTI_DISABLE_FALLING_EDGE(); } while(0)
#define __HAL_PWR_PVD_EXTI_EVENT_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_EVENT
#define __HAL_PWR_PVD_EXTI_EVENT_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_EVENT
#define __HAL_PWR_PVD_EXTI_FALLINGTRIGGER_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_FALLING_EDGE
#define __HAL_PWR_PVD_EXTI_FALLINGTRIGGER_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_FALLING_EDGE
#define __HAL_PWR_PVD_EXTI_RISINGTRIGGER_DISABLE __HAL_PWR_PVD_EXTI_DISABLE_RISING_EDGE
#define __HAL_PWR_PVD_EXTI_RISINGTRIGGER_ENABLE __HAL_PWR_PVD_EXTI_ENABLE_RISING_EDGE
#define __HAL_PWR_PVD_EXTI_SET_FALLING_EGDE_TRIGGER __HAL_PWR_PVD_EXTI_ENABLE_FALLING_EDGE
#define __HAL_PWR_PVD_EXTI_SET_RISING_EDGE_TRIGGER __HAL_PWR_PVD_EXTI_ENABLE_RISING_EDGE
#define __HAL_PWR_PVM_DISABLE() do { HAL_PWREx_DisablePVM1();HAL_PWREx_DisablePVM2();HAL_PWREx_DisablePVM3();HAL_PWREx_DisablePVM4(); } while(0)
#define __HAL_PWR_PVM_ENABLE() do { HAL_PWREx_EnablePVM1();HAL_PWREx_EnablePVM2();HAL_PWREx_EnablePVM3();HAL_PWREx_EnablePVM4(); } while(0)
#define __HAL_PWR_SRAM2CONTENT_PRESERVE_DISABLE HAL_PWREx_DisableSRAM2ContentRetention
#define __HAL_PWR_SRAM2CONTENT_PRESERVE_ENABLE HAL_PWREx_EnableSRAM2ContentRetention
#define __HAL_PWR_VDDIO2_DISABLE HAL_PWREx_DisableVddIO2
#define __HAL_PWR_VDDIO2_ENABLE HAL_PWREx_EnableVddIO2
#define __HAL_PWR_VDDIO2_EXTI_CLEAR_EGDE_TRIGGER __HAL_PWR_VDDIO2_EXTI_DISABLE_FALLING_EDGE
#define __HAL_PWR_VDDIO2_EXTI_SET_FALLING_EGDE_TRIGGER __HAL_PWR_VDDIO2_EXTI_ENABLE_FALLING_EDGE
#define __HAL_PWR_VDDUSB_DISABLE HAL_PWREx_DisableVddUSB
#define __HAL_PWR_VDDUSB_ENABLE HAL_PWREx_EnableVddUSB
#if defined (STM32F4)
#define __HAL_PVD_EXTI_ENABLE_IT(PWR_EXTI_LINE_PVD) __HAL_PWR_PVD_EXTI_ENABLE_IT()
#define __HAL_PVD_EXTI_DISABLE_IT(PWR_EXTI_LINE_PVD) __HAL_PWR_PVD_EXTI_DISABLE_IT()
#define __HAL_PVD_EXTI_GET_FLAG(PWR_EXTI_LINE_PVD) __HAL_PWR_PVD_EXTI_GET_FLAG()
#define __HAL_PVD_EXTI_CLEAR_FLAG(PWR_EXTI_LINE_PVD) __HAL_PWR_PVD_EXTI_CLEAR_FLAG()
#define __HAL_PVD_EXTI_GENERATE_SWIT(PWR_EXTI_LINE_PVD) __HAL_PWR_PVD_EXTI_GENERATE_SWIT()
#else
#define __HAL_PVD_EXTI_CLEAR_FLAG __HAL_PWR_PVD_EXTI_CLEAR_FLAG
#define __HAL_PVD_EXTI_DISABLE_IT __HAL_PWR_PVD_EXTI_DISABLE_IT
#define __HAL_PVD_EXTI_ENABLE_IT __HAL_PWR_PVD_EXTI_ENABLE_IT
#define __HAL_PVD_EXTI_GENERATE_SWIT __HAL_PWR_PVD_EXTI_GENERATE_SWIT
#define __HAL_PVD_EXTI_GET_FLAG __HAL_PWR_PVD_EXTI_GET_FLAG
#endif /* STM32F4 */
/**
* @}
*/
/** @defgroup HAL_RCC_Aliased HAL RCC Aliased maintained for legacy purpose
* @{
*/
#define RCC_StopWakeUpClock_MSI RCC_STOP_WAKEUPCLOCK_MSI
#define RCC_StopWakeUpClock_HSI RCC_STOP_WAKEUPCLOCK_HSI
#define HAL_RCC_CCSCallback HAL_RCC_CSSCallback
#define HAL_RC48_EnableBuffer_Cmd(cmd) (((cmd)==ENABLE) ? HAL_RCCEx_EnableHSI48_VREFINT() : HAL_RCCEx_DisableHSI48_VREFINT())
#define __ADC_CLK_DISABLE __HAL_RCC_ADC_CLK_DISABLE
#define __ADC_CLK_ENABLE __HAL_RCC_ADC_CLK_ENABLE
#define __ADC_CLK_SLEEP_DISABLE __HAL_RCC_ADC_CLK_SLEEP_DISABLE
#define __ADC_CLK_SLEEP_ENABLE __HAL_RCC_ADC_CLK_SLEEP_ENABLE
#define __ADC_FORCE_RESET __HAL_RCC_ADC_FORCE_RESET
#define __ADC_RELEASE_RESET __HAL_RCC_ADC_RELEASE_RESET
#define __ADC1_CLK_DISABLE __HAL_RCC_ADC1_CLK_DISABLE
#define __ADC1_CLK_ENABLE __HAL_RCC_ADC1_CLK_ENABLE
#define __ADC1_FORCE_RESET __HAL_RCC_ADC1_FORCE_RESET
#define __ADC1_RELEASE_RESET __HAL_RCC_ADC1_RELEASE_RESET
#define __ADC1_CLK_SLEEP_ENABLE __HAL_RCC_ADC1_CLK_SLEEP_ENABLE
#define __ADC1_CLK_SLEEP_DISABLE __HAL_RCC_ADC1_CLK_SLEEP_DISABLE
#define __ADC2_CLK_DISABLE __HAL_RCC_ADC2_CLK_DISABLE
#define __ADC2_CLK_ENABLE __HAL_RCC_ADC2_CLK_ENABLE
#define __ADC2_FORCE_RESET __HAL_RCC_ADC2_FORCE_RESET
#define __ADC2_RELEASE_RESET __HAL_RCC_ADC2_RELEASE_RESET
#define __ADC3_CLK_DISABLE __HAL_RCC_ADC3_CLK_DISABLE
#define __ADC3_CLK_ENABLE __HAL_RCC_ADC3_CLK_ENABLE
#define __ADC3_FORCE_RESET __HAL_RCC_ADC3_FORCE_RESET
#define __ADC3_RELEASE_RESET __HAL_RCC_ADC3_RELEASE_RESET
#define __AES_CLK_DISABLE __HAL_RCC_AES_CLK_DISABLE
#define __AES_CLK_ENABLE __HAL_RCC_AES_CLK_ENABLE
#define __AES_CLK_SLEEP_DISABLE __HAL_RCC_AES_CLK_SLEEP_DISABLE
#define __AES_CLK_SLEEP_ENABLE __HAL_RCC_AES_CLK_SLEEP_ENABLE
#define __AES_FORCE_RESET __HAL_RCC_AES_FORCE_RESET
#define __AES_RELEASE_RESET __HAL_RCC_AES_RELEASE_RESET
#define __CRYP_CLK_SLEEP_ENABLE __HAL_RCC_CRYP_CLK_SLEEP_ENABLE
#define __CRYP_CLK_SLEEP_DISABLE __HAL_RCC_CRYP_CLK_SLEEP_DISABLE
#define __CRYP_CLK_ENABLE __HAL_RCC_CRYP_CLK_ENABLE
#define __CRYP_CLK_DISABLE __HAL_RCC_CRYP_CLK_DISABLE
#define __CRYP_FORCE_RESET __HAL_RCC_CRYP_FORCE_RESET
#define __CRYP_RELEASE_RESET __HAL_RCC_CRYP_RELEASE_RESET
#define __AFIO_CLK_DISABLE __HAL_RCC_AFIO_CLK_DISABLE
#define __AFIO_CLK_ENABLE __HAL_RCC_AFIO_CLK_ENABLE
#define __AFIO_FORCE_RESET __HAL_RCC_AFIO_FORCE_RESET
#define __AFIO_RELEASE_RESET __HAL_RCC_AFIO_RELEASE_RESET
#define __AHB_FORCE_RESET __HAL_RCC_AHB_FORCE_RESET
#define __AHB_RELEASE_RESET __HAL_RCC_AHB_RELEASE_RESET
#define __AHB1_FORCE_RESET __HAL_RCC_AHB1_FORCE_RESET
#define __AHB1_RELEASE_RESET __HAL_RCC_AHB1_RELEASE_RESET
#define __AHB2_FORCE_RESET __HAL_RCC_AHB2_FORCE_RESET
#define __AHB2_RELEASE_RESET __HAL_RCC_AHB2_RELEASE_RESET
#define __AHB3_FORCE_RESET __HAL_RCC_AHB3_FORCE_RESET
#define __AHB3_RELEASE_RESET __HAL_RCC_AHB3_RELEASE_RESET
#define __APB1_FORCE_RESET __HAL_RCC_APB1_FORCE_RESET
#define __APB1_RELEASE_RESET __HAL_RCC_APB1_RELEASE_RESET
#define __APB2_FORCE_RESET __HAL_RCC_APB2_FORCE_RESET
#define __APB2_RELEASE_RESET __HAL_RCC_APB2_RELEASE_RESET
#define __BKP_CLK_DISABLE __HAL_RCC_BKP_CLK_DISABLE
#define __BKP_CLK_ENABLE __HAL_RCC_BKP_CLK_ENABLE
#define __BKP_FORCE_RESET __HAL_RCC_BKP_FORCE_RESET
#define __BKP_RELEASE_RESET __HAL_RCC_BKP_RELEASE_RESET
#define __CAN1_CLK_DISABLE __HAL_RCC_CAN1_CLK_DISABLE
#define __CAN1_CLK_ENABLE __HAL_RCC_CAN1_CLK_ENABLE
#define __CAN1_CLK_SLEEP_DISABLE __HAL_RCC_CAN1_CLK_SLEEP_DISABLE
#define __CAN1_CLK_SLEEP_ENABLE __HAL_RCC_CAN1_CLK_SLEEP_ENABLE
#define __CAN1_FORCE_RESET __HAL_RCC_CAN1_FORCE_RESET
#define __CAN1_RELEASE_RESET __HAL_RCC_CAN1_RELEASE_RESET
#define __CAN_CLK_DISABLE __HAL_RCC_CAN1_CLK_DISABLE
#define __CAN_CLK_ENABLE __HAL_RCC_CAN1_CLK_ENABLE
#define __CAN_FORCE_RESET __HAL_RCC_CAN1_FORCE_RESET
#define __CAN_RELEASE_RESET __HAL_RCC_CAN1_RELEASE_RESET
#define __CAN2_CLK_DISABLE __HAL_RCC_CAN2_CLK_DISABLE
#define __CAN2_CLK_ENABLE __HAL_RCC_CAN2_CLK_ENABLE
#define __CAN2_FORCE_RESET __HAL_RCC_CAN2_FORCE_RESET
#define __CAN2_RELEASE_RESET __HAL_RCC_CAN2_RELEASE_RESET
#define __CEC_CLK_DISABLE __HAL_RCC_CEC_CLK_DISABLE
#define __CEC_CLK_ENABLE __HAL_RCC_CEC_CLK_ENABLE
#define __COMP_CLK_DISABLE __HAL_RCC_COMP_CLK_DISABLE
#define __COMP_CLK_ENABLE __HAL_RCC_COMP_CLK_ENABLE
#define __COMP_FORCE_RESET __HAL_RCC_COMP_FORCE_RESET
#define __COMP_RELEASE_RESET __HAL_RCC_COMP_RELEASE_RESET
#define __COMP_CLK_SLEEP_ENABLE __HAL_RCC_COMP_CLK_SLEEP_ENABLE
#define __COMP_CLK_SLEEP_DISABLE __HAL_RCC_COMP_CLK_SLEEP_DISABLE
#define __CEC_FORCE_RESET __HAL_RCC_CEC_FORCE_RESET
#define __CEC_RELEASE_RESET __HAL_RCC_CEC_RELEASE_RESET
#define __CRC_CLK_DISABLE __HAL_RCC_CRC_CLK_DISABLE
#define __CRC_CLK_ENABLE __HAL_RCC_CRC_CLK_ENABLE
#define __CRC_CLK_SLEEP_DISABLE __HAL_RCC_CRC_CLK_SLEEP_DISABLE
#define __CRC_CLK_SLEEP_ENABLE __HAL_RCC_CRC_CLK_SLEEP_ENABLE
#define __CRC_FORCE_RESET __HAL_RCC_CRC_FORCE_RESET
#define __CRC_RELEASE_RESET __HAL_RCC_CRC_RELEASE_RESET
#define __DAC_CLK_DISABLE __HAL_RCC_DAC_CLK_DISABLE
#define __DAC_CLK_ENABLE __HAL_RCC_DAC_CLK_ENABLE
#define __DAC_FORCE_RESET __HAL_RCC_DAC_FORCE_RESET
#define __DAC_RELEASE_RESET __HAL_RCC_DAC_RELEASE_RESET
#define __DAC1_CLK_DISABLE __HAL_RCC_DAC1_CLK_DISABLE
#define __DAC1_CLK_ENABLE __HAL_RCC_DAC1_CLK_ENABLE
#define __DAC1_CLK_SLEEP_DISABLE __HAL_RCC_DAC1_CLK_SLEEP_DISABLE
#define __DAC1_CLK_SLEEP_ENABLE __HAL_RCC_DAC1_CLK_SLEEP_ENABLE
#define __DAC1_FORCE_RESET __HAL_RCC_DAC1_FORCE_RESET
#define __DAC1_RELEASE_RESET __HAL_RCC_DAC1_RELEASE_RESET
#define __DBGMCU_CLK_ENABLE __HAL_RCC_DBGMCU_CLK_ENABLE
#define __DBGMCU_CLK_DISABLE __HAL_RCC_DBGMCU_CLK_DISABLE
#define __DBGMCU_FORCE_RESET __HAL_RCC_DBGMCU_FORCE_RESET
#define __DBGMCU_RELEASE_RESET __HAL_RCC_DBGMCU_RELEASE_RESET
#define __DFSDM_CLK_DISABLE __HAL_RCC_DFSDM_CLK_DISABLE
#define __DFSDM_CLK_ENABLE __HAL_RCC_DFSDM_CLK_ENABLE
#define __DFSDM_CLK_SLEEP_DISABLE __HAL_RCC_DFSDM_CLK_SLEEP_DISABLE
#define __DFSDM_CLK_SLEEP_ENABLE __HAL_RCC_DFSDM_CLK_SLEEP_ENABLE
#define __DFSDM_FORCE_RESET __HAL_RCC_DFSDM_FORCE_RESET
#define __DFSDM_RELEASE_RESET __HAL_RCC_DFSDM_RELEASE_RESET
#define __DMA1_CLK_DISABLE __HAL_RCC_DMA1_CLK_DISABLE
#define __DMA1_CLK_ENABLE __HAL_RCC_DMA1_CLK_ENABLE
#define __DMA1_CLK_SLEEP_DISABLE __HAL_RCC_DMA1_CLK_SLEEP_DISABLE
#define __DMA1_CLK_SLEEP_ENABLE __HAL_RCC_DMA1_CLK_SLEEP_ENABLE
#define __DMA1_FORCE_RESET __HAL_RCC_DMA1_FORCE_RESET
#define __DMA1_RELEASE_RESET __HAL_RCC_DMA1_RELEASE_RESET
#define __DMA2_CLK_DISABLE __HAL_RCC_DMA2_CLK_DISABLE
#define __DMA2_CLK_ENABLE __HAL_RCC_DMA2_CLK_ENABLE
#define __DMA2_CLK_SLEEP_DISABLE __HAL_RCC_DMA2_CLK_SLEEP_DISABLE
#define __DMA2_CLK_SLEEP_ENABLE __HAL_RCC_DMA2_CLK_SLEEP_ENABLE
#define __DMA2_FORCE_RESET __HAL_RCC_DMA2_FORCE_RESET
#define __DMA2_RELEASE_RESET __HAL_RCC_DMA2_RELEASE_RESET
#define __ETHMAC_CLK_DISABLE __HAL_RCC_ETHMAC_CLK_DISABLE
#define __ETHMAC_CLK_ENABLE __HAL_RCC_ETHMAC_CLK_ENABLE
#define __ETHMAC_FORCE_RESET __HAL_RCC_ETHMAC_FORCE_RESET
#define __ETHMAC_RELEASE_RESET __HAL_RCC_ETHMAC_RELEASE_RESET
#define __ETHMACRX_CLK_DISABLE __HAL_RCC_ETHMACRX_CLK_DISABLE
#define __ETHMACRX_CLK_ENABLE __HAL_RCC_ETHMACRX_CLK_ENABLE
#define __ETHMACTX_CLK_DISABLE __HAL_RCC_ETHMACTX_CLK_DISABLE
#define __ETHMACTX_CLK_ENABLE __HAL_RCC_ETHMACTX_CLK_ENABLE
#define __FIREWALL_CLK_DISABLE __HAL_RCC_FIREWALL_CLK_DISABLE
#define __FIREWALL_CLK_ENABLE __HAL_RCC_FIREWALL_CLK_ENABLE
#define __FLASH_CLK_DISABLE __HAL_RCC_FLASH_CLK_DISABLE
#define __FLASH_CLK_ENABLE __HAL_RCC_FLASH_CLK_ENABLE
#define __FLASH_CLK_SLEEP_DISABLE __HAL_RCC_FLASH_CLK_SLEEP_DISABLE
#define __FLASH_CLK_SLEEP_ENABLE __HAL_RCC_FLASH_CLK_SLEEP_ENABLE
#define __FLASH_FORCE_RESET __HAL_RCC_FLASH_FORCE_RESET
#define __FLASH_RELEASE_RESET __HAL_RCC_FLASH_RELEASE_RESET
#define __FLITF_CLK_DISABLE __HAL_RCC_FLITF_CLK_DISABLE
#define __FLITF_CLK_ENABLE __HAL_RCC_FLITF_CLK_ENABLE
#define __FLITF_FORCE_RESET __HAL_RCC_FLITF_FORCE_RESET
#define __FLITF_RELEASE_RESET __HAL_RCC_FLITF_RELEASE_RESET
#define __FLITF_CLK_SLEEP_ENABLE __HAL_RCC_FLITF_CLK_SLEEP_ENABLE
#define __FLITF_CLK_SLEEP_DISABLE __HAL_RCC_FLITF_CLK_SLEEP_DISABLE
#define __FMC_CLK_DISABLE __HAL_RCC_FMC_CLK_DISABLE
#define __FMC_CLK_ENABLE __HAL_RCC_FMC_CLK_ENABLE
#define __FMC_CLK_SLEEP_DISABLE __HAL_RCC_FMC_CLK_SLEEP_DISABLE
#define __FMC_CLK_SLEEP_ENABLE __HAL_RCC_FMC_CLK_SLEEP_ENABLE
#define __FMC_FORCE_RESET __HAL_RCC_FMC_FORCE_RESET
#define __FMC_RELEASE_RESET __HAL_RCC_FMC_RELEASE_RESET
#define __FSMC_CLK_DISABLE __HAL_RCC_FSMC_CLK_DISABLE
#define __FSMC_CLK_ENABLE __HAL_RCC_FSMC_CLK_ENABLE
#define __GPIOA_CLK_DISABLE __HAL_RCC_GPIOA_CLK_DISABLE
#define __GPIOA_CLK_ENABLE __HAL_RCC_GPIOA_CLK_ENABLE
#define __GPIOA_CLK_SLEEP_DISABLE __HAL_RCC_GPIOA_CLK_SLEEP_DISABLE
#define __GPIOA_CLK_SLEEP_ENABLE __HAL_RCC_GPIOA_CLK_SLEEP_ENABLE
#define __GPIOA_FORCE_RESET __HAL_RCC_GPIOA_FORCE_RESET
#define __GPIOA_RELEASE_RESET __HAL_RCC_GPIOA_RELEASE_RESET
#define __GPIOB_CLK_DISABLE __HAL_RCC_GPIOB_CLK_DISABLE
#define __GPIOB_CLK_ENABLE __HAL_RCC_GPIOB_CLK_ENABLE
#define __GPIOB_CLK_SLEEP_DISABLE __HAL_RCC_GPIOB_CLK_SLEEP_DISABLE
#define __GPIOB_CLK_SLEEP_ENABLE __HAL_RCC_GPIOB_CLK_SLEEP_ENABLE
#define __GPIOB_FORCE_RESET __HAL_RCC_GPIOB_FORCE_RESET
#define __GPIOB_RELEASE_RESET __HAL_RCC_GPIOB_RELEASE_RESET
#define __GPIOC_CLK_DISABLE __HAL_RCC_GPIOC_CLK_DISABLE
#define __GPIOC_CLK_ENABLE __HAL_RCC_GPIOC_CLK_ENABLE
#define __GPIOC_CLK_SLEEP_DISABLE __HAL_RCC_GPIOC_CLK_SLEEP_DISABLE
#define __GPIOC_CLK_SLEEP_ENABLE __HAL_RCC_GPIOC_CLK_SLEEP_ENABLE
#define __GPIOC_FORCE_RESET __HAL_RCC_GPIOC_FORCE_RESET
#define __GPIOC_RELEASE_RESET __HAL_RCC_GPIOC_RELEASE_RESET
#define __GPIOD_CLK_DISABLE __HAL_RCC_GPIOD_CLK_DISABLE
#define __GPIOD_CLK_ENABLE __HAL_RCC_GPIOD_CLK_ENABLE
#define __GPIOD_CLK_SLEEP_DISABLE __HAL_RCC_GPIOD_CLK_SLEEP_DISABLE
#define __GPIOD_CLK_SLEEP_ENABLE __HAL_RCC_GPIOD_CLK_SLEEP_ENABLE
#define __GPIOD_FORCE_RESET __HAL_RCC_GPIOD_FORCE_RESET
#define __GPIOD_RELEASE_RESET __HAL_RCC_GPIOD_RELEASE_RESET
#define __GPIOE_CLK_DISABLE __HAL_RCC_GPIOE_CLK_DISABLE
#define __GPIOE_CLK_ENABLE __HAL_RCC_GPIOE_CLK_ENABLE
#define __GPIOE_CLK_SLEEP_DISABLE __HAL_RCC_GPIOE_CLK_SLEEP_DISABLE
#define __GPIOE_CLK_SLEEP_ENABLE __HAL_RCC_GPIOE_CLK_SLEEP_ENABLE
#define __GPIOE_FORCE_RESET __HAL_RCC_GPIOE_FORCE_RESET
#define __GPIOE_RELEASE_RESET __HAL_RCC_GPIOE_RELEASE_RESET
#define __GPIOF_CLK_DISABLE __HAL_RCC_GPIOF_CLK_DISABLE
#define __GPIOF_CLK_ENABLE __HAL_RCC_GPIOF_CLK_ENABLE
#define __GPIOF_CLK_SLEEP_DISABLE __HAL_RCC_GPIOF_CLK_SLEEP_DISABLE
#define __GPIOF_CLK_SLEEP_ENABLE __HAL_RCC_GPIOF_CLK_SLEEP_ENABLE
#define __GPIOF_FORCE_RESET __HAL_RCC_GPIOF_FORCE_RESET
#define __GPIOF_RELEASE_RESET __HAL_RCC_GPIOF_RELEASE_RESET
#define __GPIOG_CLK_DISABLE __HAL_RCC_GPIOG_CLK_DISABLE
#define __GPIOG_CLK_ENABLE __HAL_RCC_GPIOG_CLK_ENABLE
#define __GPIOG_CLK_SLEEP_DISABLE __HAL_RCC_GPIOG_CLK_SLEEP_DISABLE
#define __GPIOG_CLK_SLEEP_ENABLE __HAL_RCC_GPIOG_CLK_SLEEP_ENABLE
#define __GPIOG_FORCE_RESET __HAL_RCC_GPIOG_FORCE_RESET
#define __GPIOG_RELEASE_RESET __HAL_RCC_GPIOG_RELEASE_RESET
#define __GPIOH_CLK_DISABLE __HAL_RCC_GPIOH_CLK_DISABLE
#define __GPIOH_CLK_ENABLE __HAL_RCC_GPIOH_CLK_ENABLE
#define __GPIOH_CLK_SLEEP_DISABLE __HAL_RCC_GPIOH_CLK_SLEEP_DISABLE
#define __GPIOH_CLK_SLEEP_ENABLE __HAL_RCC_GPIOH_CLK_SLEEP_ENABLE
#define __GPIOH_FORCE_RESET __HAL_RCC_GPIOH_FORCE_RESET
#define __GPIOH_RELEASE_RESET __HAL_RCC_GPIOH_RELEASE_RESET
#define __I2C1_CLK_DISABLE __HAL_RCC_I2C1_CLK_DISABLE
#define __I2C1_CLK_ENABLE __HAL_RCC_I2C1_CLK_ENABLE
#define __I2C1_CLK_SLEEP_DISABLE __HAL_RCC_I2C1_CLK_SLEEP_DISABLE
#define __I2C1_CLK_SLEEP_ENABLE __HAL_RCC_I2C1_CLK_SLEEP_ENABLE
#define __I2C1_FORCE_RESET __HAL_RCC_I2C1_FORCE_RESET
#define __I2C1_RELEASE_RESET __HAL_RCC_I2C1_RELEASE_RESET
#define __I2C2_CLK_DISABLE __HAL_RCC_I2C2_CLK_DISABLE
#define __I2C2_CLK_ENABLE __HAL_RCC_I2C2_CLK_ENABLE
#define __I2C2_CLK_SLEEP_DISABLE __HAL_RCC_I2C2_CLK_SLEEP_DISABLE
#define __I2C2_CLK_SLEEP_ENABLE __HAL_RCC_I2C2_CLK_SLEEP_ENABLE
#define __I2C2_FORCE_RESET __HAL_RCC_I2C2_FORCE_RESET
#define __I2C2_RELEASE_RESET __HAL_RCC_I2C2_RELEASE_RESET
#define __I2C3_CLK_DISABLE __HAL_RCC_I2C3_CLK_DISABLE
#define __I2C3_CLK_ENABLE __HAL_RCC_I2C3_CLK_ENABLE
#define __I2C3_CLK_SLEEP_DISABLE __HAL_RCC_I2C3_CLK_SLEEP_DISABLE
#define __I2C3_CLK_SLEEP_ENABLE __HAL_RCC_I2C3_CLK_SLEEP_ENABLE
#define __I2C3_FORCE_RESET __HAL_RCC_I2C3_FORCE_RESET
#define __I2C3_RELEASE_RESET __HAL_RCC_I2C3_RELEASE_RESET
#define __LCD_CLK_DISABLE __HAL_RCC_LCD_CLK_DISABLE
#define __LCD_CLK_ENABLE __HAL_RCC_LCD_CLK_ENABLE
#define __LCD_CLK_SLEEP_DISABLE __HAL_RCC_LCD_CLK_SLEEP_DISABLE
#define __LCD_CLK_SLEEP_ENABLE __HAL_RCC_LCD_CLK_SLEEP_ENABLE
#define __LCD_FORCE_RESET __HAL_RCC_LCD_FORCE_RESET
#define __LCD_RELEASE_RESET __HAL_RCC_LCD_RELEASE_RESET
#define __LPTIM1_CLK_DISABLE __HAL_RCC_LPTIM1_CLK_DISABLE
#define __LPTIM1_CLK_ENABLE __HAL_RCC_LPTIM1_CLK_ENABLE
#define __LPTIM1_CLK_SLEEP_DISABLE __HAL_RCC_LPTIM1_CLK_SLEEP_DISABLE
#define __LPTIM1_CLK_SLEEP_ENABLE __HAL_RCC_LPTIM1_CLK_SLEEP_ENABLE
#define __LPTIM1_FORCE_RESET __HAL_RCC_LPTIM1_FORCE_RESET
#define __LPTIM1_RELEASE_RESET __HAL_RCC_LPTIM1_RELEASE_RESET
#define __LPTIM2_CLK_DISABLE __HAL_RCC_LPTIM2_CLK_DISABLE
#define __LPTIM2_CLK_ENABLE __HAL_RCC_LPTIM2_CLK_ENABLE
#define __LPTIM2_CLK_SLEEP_DISABLE __HAL_RCC_LPTIM2_CLK_SLEEP_DISABLE
#define __LPTIM2_CLK_SLEEP_ENABLE __HAL_RCC_LPTIM2_CLK_SLEEP_ENABLE
#define __LPTIM2_FORCE_RESET __HAL_RCC_LPTIM2_FORCE_RESET
#define __LPTIM2_RELEASE_RESET __HAL_RCC_LPTIM2_RELEASE_RESET
#define __LPUART1_CLK_DISABLE __HAL_RCC_LPUART1_CLK_DISABLE
#define __LPUART1_CLK_ENABLE __HAL_RCC_LPUART1_CLK_ENABLE
#define __LPUART1_CLK_SLEEP_DISABLE __HAL_RCC_LPUART1_CLK_SLEEP_DISABLE
#define __LPUART1_CLK_SLEEP_ENABLE __HAL_RCC_LPUART1_CLK_SLEEP_ENABLE
#define __LPUART1_FORCE_RESET __HAL_RCC_LPUART1_FORCE_RESET
#define __LPUART1_RELEASE_RESET __HAL_RCC_LPUART1_RELEASE_RESET
#define __OPAMP_CLK_DISABLE __HAL_RCC_OPAMP_CLK_DISABLE
#define __OPAMP_CLK_ENABLE __HAL_RCC_OPAMP_CLK_ENABLE
#define __OPAMP_CLK_SLEEP_DISABLE __HAL_RCC_OPAMP_CLK_SLEEP_DISABLE
#define __OPAMP_CLK_SLEEP_ENABLE __HAL_RCC_OPAMP_CLK_SLEEP_ENABLE
#define __OPAMP_FORCE_RESET __HAL_RCC_OPAMP_FORCE_RESET
#define __OPAMP_RELEASE_RESET __HAL_RCC_OPAMP_RELEASE_RESET
#define __OTGFS_CLK_DISABLE __HAL_RCC_OTGFS_CLK_DISABLE
#define __OTGFS_CLK_ENABLE __HAL_RCC_OTGFS_CLK_ENABLE
#define __OTGFS_CLK_SLEEP_DISABLE __HAL_RCC_OTGFS_CLK_SLEEP_DISABLE
#define __OTGFS_CLK_SLEEP_ENABLE __HAL_RCC_OTGFS_CLK_SLEEP_ENABLE
#define __OTGFS_FORCE_RESET __HAL_RCC_OTGFS_FORCE_RESET
#define __OTGFS_RELEASE_RESET __HAL_RCC_OTGFS_RELEASE_RESET
#define __PWR_CLK_DISABLE __HAL_RCC_PWR_CLK_DISABLE
#define __PWR_CLK_ENABLE __HAL_RCC_PWR_CLK_ENABLE
#define __PWR_CLK_SLEEP_DISABLE __HAL_RCC_PWR_CLK_SLEEP_DISABLE
#define __PWR_CLK_SLEEP_ENABLE __HAL_RCC_PWR_CLK_SLEEP_ENABLE
#define __PWR_FORCE_RESET __HAL_RCC_PWR_FORCE_RESET
#define __PWR_RELEASE_RESET __HAL_RCC_PWR_RELEASE_RESET
#define __QSPI_CLK_DISABLE __HAL_RCC_QSPI_CLK_DISABLE
#define __QSPI_CLK_ENABLE __HAL_RCC_QSPI_CLK_ENABLE
#define __QSPI_CLK_SLEEP_DISABLE __HAL_RCC_QSPI_CLK_SLEEP_DISABLE
#define __QSPI_CLK_SLEEP_ENABLE __HAL_RCC_QSPI_CLK_SLEEP_ENABLE
#define __QSPI_FORCE_RESET __HAL_RCC_QSPI_FORCE_RESET
#define __QSPI_RELEASE_RESET __HAL_RCC_QSPI_RELEASE_RESET
#define __RNG_CLK_DISABLE __HAL_RCC_RNG_CLK_DISABLE
#define __RNG_CLK_ENABLE __HAL_RCC_RNG_CLK_ENABLE
#define __RNG_CLK_SLEEP_DISABLE __HAL_RCC_RNG_CLK_SLEEP_DISABLE
#define __RNG_CLK_SLEEP_ENABLE __HAL_RCC_RNG_CLK_SLEEP_ENABLE
#define __RNG_FORCE_RESET __HAL_RCC_RNG_FORCE_RESET
#define __RNG_RELEASE_RESET __HAL_RCC_RNG_RELEASE_RESET
#define __SAI1_CLK_DISABLE __HAL_RCC_SAI1_CLK_DISABLE
#define __SAI1_CLK_ENABLE __HAL_RCC_SAI1_CLK_ENABLE
#define __SAI1_CLK_SLEEP_DISABLE __HAL_RCC_SAI1_CLK_SLEEP_DISABLE
#define __SAI1_CLK_SLEEP_ENABLE __HAL_RCC_SAI1_CLK_SLEEP_ENABLE
#define __SAI1_FORCE_RESET __HAL_RCC_SAI1_FORCE_RESET
#define __SAI1_RELEASE_RESET __HAL_RCC_SAI1_RELEASE_RESET
#define __SAI2_CLK_DISABLE __HAL_RCC_SAI2_CLK_DISABLE
#define __SAI2_CLK_ENABLE __HAL_RCC_SAI2_CLK_ENABLE
#define __SAI2_CLK_SLEEP_DISABLE __HAL_RCC_SAI2_CLK_SLEEP_DISABLE
#define __SAI2_CLK_SLEEP_ENABLE __HAL_RCC_SAI2_CLK_SLEEP_ENABLE
#define __SAI2_FORCE_RESET __HAL_RCC_SAI2_FORCE_RESET
#define __SAI2_RELEASE_RESET __HAL_RCC_SAI2_RELEASE_RESET
#define __SDIO_CLK_DISABLE __HAL_RCC_SDIO_CLK_DISABLE
#define __SDIO_CLK_ENABLE __HAL_RCC_SDIO_CLK_ENABLE
#define __SDMMC_CLK_DISABLE __HAL_RCC_SDMMC_CLK_DISABLE
#define __SDMMC_CLK_ENABLE __HAL_RCC_SDMMC_CLK_ENABLE
#define __SDMMC_CLK_SLEEP_DISABLE __HAL_RCC_SDMMC_CLK_SLEEP_DISABLE
#define __SDMMC_CLK_SLEEP_ENABLE __HAL_RCC_SDMMC_CLK_SLEEP_ENABLE
#define __SDMMC_FORCE_RESET __HAL_RCC_SDMMC_FORCE_RESET
#define __SDMMC_RELEASE_RESET __HAL_RCC_SDMMC_RELEASE_RESET
#define __SPI1_CLK_DISABLE __HAL_RCC_SPI1_CLK_DISABLE
#define __SPI1_CLK_ENABLE __HAL_RCC_SPI1_CLK_ENABLE
#define __SPI1_CLK_SLEEP_DISABLE __HAL_RCC_SPI1_CLK_SLEEP_DISABLE
#define __SPI1_CLK_SLEEP_ENABLE __HAL_RCC_SPI1_CLK_SLEEP_ENABLE
#define __SPI1_FORCE_RESET __HAL_RCC_SPI1_FORCE_RESET
#define __SPI1_RELEASE_RESET __HAL_RCC_SPI1_RELEASE_RESET
#define __SPI2_CLK_DISABLE __HAL_RCC_SPI2_CLK_DISABLE
#define __SPI2_CLK_ENABLE __HAL_RCC_SPI2_CLK_ENABLE
#define __SPI2_CLK_SLEEP_DISABLE __HAL_RCC_SPI2_CLK_SLEEP_DISABLE
#define __SPI2_CLK_SLEEP_ENABLE __HAL_RCC_SPI2_CLK_SLEEP_ENABLE
#define __SPI2_FORCE_RESET __HAL_RCC_SPI2_FORCE_RESET
#define __SPI2_RELEASE_RESET __HAL_RCC_SPI2_RELEASE_RESET
#define __SPI3_CLK_DISABLE __HAL_RCC_SPI3_CLK_DISABLE
#define __SPI3_CLK_ENABLE __HAL_RCC_SPI3_CLK_ENABLE
#define __SPI3_CLK_SLEEP_DISABLE __HAL_RCC_SPI3_CLK_SLEEP_DISABLE
#define __SPI3_CLK_SLEEP_ENABLE __HAL_RCC_SPI3_CLK_SLEEP_ENABLE
#define __SPI3_FORCE_RESET __HAL_RCC_SPI3_FORCE_RESET
#define __SPI3_RELEASE_RESET __HAL_RCC_SPI3_RELEASE_RESET
#define __SRAM_CLK_DISABLE __HAL_RCC_SRAM_CLK_DISABLE
#define __SRAM_CLK_ENABLE __HAL_RCC_SRAM_CLK_ENABLE
#define __SRAM1_CLK_SLEEP_DISABLE __HAL_RCC_SRAM1_CLK_SLEEP_DISABLE
#define __SRAM1_CLK_SLEEP_ENABLE __HAL_RCC_SRAM1_CLK_SLEEP_ENABLE
#define __SRAM2_CLK_SLEEP_DISABLE __HAL_RCC_SRAM2_CLK_SLEEP_DISABLE
#define __SRAM2_CLK_SLEEP_ENABLE __HAL_RCC_SRAM2_CLK_SLEEP_ENABLE
#define __SWPMI1_CLK_DISABLE __HAL_RCC_SWPMI1_CLK_DISABLE
#define __SWPMI1_CLK_ENABLE __HAL_RCC_SWPMI1_CLK_ENABLE
#define __SWPMI1_CLK_SLEEP_DISABLE __HAL_RCC_SWPMI1_CLK_SLEEP_DISABLE
#define __SWPMI1_CLK_SLEEP_ENABLE __HAL_RCC_SWPMI1_CLK_SLEEP_ENABLE
#define __SWPMI1_FORCE_RESET __HAL_RCC_SWPMI1_FORCE_RESET
#define __SWPMI1_RELEASE_RESET __HAL_RCC_SWPMI1_RELEASE_RESET
#define __SYSCFG_CLK_DISABLE __HAL_RCC_SYSCFG_CLK_DISABLE
#define __SYSCFG_CLK_ENABLE __HAL_RCC_SYSCFG_CLK_ENABLE
#define __SYSCFG_CLK_SLEEP_DISABLE __HAL_RCC_SYSCFG_CLK_SLEEP_DISABLE
#define __SYSCFG_CLK_SLEEP_ENABLE __HAL_RCC_SYSCFG_CLK_SLEEP_ENABLE
#define __SYSCFG_FORCE_RESET __HAL_RCC_SYSCFG_FORCE_RESET
#define __SYSCFG_RELEASE_RESET __HAL_RCC_SYSCFG_RELEASE_RESET
#define __TIM1_CLK_DISABLE __HAL_RCC_TIM1_CLK_DISABLE
#define __TIM1_CLK_ENABLE __HAL_RCC_TIM1_CLK_ENABLE
#define __TIM1_CLK_SLEEP_DISABLE __HAL_RCC_TIM1_CLK_SLEEP_DISABLE
#define __TIM1_CLK_SLEEP_ENABLE __HAL_RCC_TIM1_CLK_SLEEP_ENABLE
#define __TIM1_FORCE_RESET __HAL_RCC_TIM1_FORCE_RESET
#define __TIM1_RELEASE_RESET __HAL_RCC_TIM1_RELEASE_RESET
#define __TIM10_CLK_DISABLE __HAL_RCC_TIM10_CLK_DISABLE
#define __TIM10_CLK_ENABLE __HAL_RCC_TIM10_CLK_ENABLE
#define __TIM10_FORCE_RESET __HAL_RCC_TIM10_FORCE_RESET
#define __TIM10_RELEASE_RESET __HAL_RCC_TIM10_RELEASE_RESET
#define __TIM11_CLK_DISABLE __HAL_RCC_TIM11_CLK_DISABLE
#define __TIM11_CLK_ENABLE __HAL_RCC_TIM11_CLK_ENABLE
#define __TIM11_FORCE_RESET __HAL_RCC_TIM11_FORCE_RESET
#define __TIM11_RELEASE_RESET __HAL_RCC_TIM11_RELEASE_RESET
#define __TIM12_CLK_DISABLE __HAL_RCC_TIM12_CLK_DISABLE
#define __TIM12_CLK_ENABLE __HAL_RCC_TIM12_CLK_ENABLE
#define __TIM12_FORCE_RESET __HAL_RCC_TIM12_FORCE_RESET
#define __TIM12_RELEASE_RESET __HAL_RCC_TIM12_RELEASE_RESET
#define __TIM13_CLK_DISABLE __HAL_RCC_TIM13_CLK_DISABLE
#define __TIM13_CLK_ENABLE __HAL_RCC_TIM13_CLK_ENABLE
#define __TIM13_FORCE_RESET __HAL_RCC_TIM13_FORCE_RESET
#define __TIM13_RELEASE_RESET __HAL_RCC_TIM13_RELEASE_RESET
#define __TIM14_CLK_DISABLE __HAL_RCC_TIM14_CLK_DISABLE
#define __TIM14_CLK_ENABLE __HAL_RCC_TIM14_CLK_ENABLE
#define __TIM14_FORCE_RESET __HAL_RCC_TIM14_FORCE_RESET
#define __TIM14_RELEASE_RESET __HAL_RCC_TIM14_RELEASE_RESET
#define __TIM15_CLK_DISABLE __HAL_RCC_TIM15_CLK_DISABLE
#define __TIM15_CLK_ENABLE __HAL_RCC_TIM15_CLK_ENABLE
#define __TIM15_CLK_SLEEP_DISABLE __HAL_RCC_TIM15_CLK_SLEEP_DISABLE
#define __TIM15_CLK_SLEEP_ENABLE __HAL_RCC_TIM15_CLK_SLEEP_ENABLE
#define __TIM15_FORCE_RESET __HAL_RCC_TIM15_FORCE_RESET
#define __TIM15_RELEASE_RESET __HAL_RCC_TIM15_RELEASE_RESET
#define __TIM16_CLK_DISABLE __HAL_RCC_TIM16_CLK_DISABLE
#define __TIM16_CLK_ENABLE __HAL_RCC_TIM16_CLK_ENABLE
#define __TIM16_CLK_SLEEP_DISABLE __HAL_RCC_TIM16_CLK_SLEEP_DISABLE
#define __TIM16_CLK_SLEEP_ENABLE __HAL_RCC_TIM16_CLK_SLEEP_ENABLE
#define __TIM16_FORCE_RESET __HAL_RCC_TIM16_FORCE_RESET
#define __TIM16_RELEASE_RESET __HAL_RCC_TIM16_RELEASE_RESET
#define __TIM17_CLK_DISABLE __HAL_RCC_TIM17_CLK_DISABLE
#define __TIM17_CLK_ENABLE __HAL_RCC_TIM17_CLK_ENABLE
#define __TIM17_CLK_SLEEP_DISABLE __HAL_RCC_TIM17_CLK_SLEEP_DISABLE
#define __TIM17_CLK_SLEEP_ENABLE __HAL_RCC_TIM17_CLK_SLEEP_ENABLE
#define __TIM17_FORCE_RESET __HAL_RCC_TIM17_FORCE_RESET
#define __TIM17_RELEASE_RESET __HAL_RCC_TIM17_RELEASE_RESET
#define __TIM2_CLK_DISABLE __HAL_RCC_TIM2_CLK_DISABLE
#define __TIM2_CLK_ENABLE __HAL_RCC_TIM2_CLK_ENABLE
#define __TIM2_CLK_SLEEP_DISABLE __HAL_RCC_TIM2_CLK_SLEEP_DISABLE
#define __TIM2_CLK_SLEEP_ENABLE __HAL_RCC_TIM2_CLK_SLEEP_ENABLE
#define __TIM2_FORCE_RESET __HAL_RCC_TIM2_FORCE_RESET
#define __TIM2_RELEASE_RESET __HAL_RCC_TIM2_RELEASE_RESET
#define __TIM3_CLK_DISABLE __HAL_RCC_TIM3_CLK_DISABLE
#define __TIM3_CLK_ENABLE __HAL_RCC_TIM3_CLK_ENABLE
#define __TIM3_CLK_SLEEP_DISABLE __HAL_RCC_TIM3_CLK_SLEEP_DISABLE
#define __TIM3_CLK_SLEEP_ENABLE __HAL_RCC_TIM3_CLK_SLEEP_ENABLE
#define __TIM3_FORCE_RESET __HAL_RCC_TIM3_FORCE_RESET
#define __TIM3_RELEASE_RESET __HAL_RCC_TIM3_RELEASE_RESET
#define __TIM4_CLK_DISABLE __HAL_RCC_TIM4_CLK_DISABLE
#define __TIM4_CLK_ENABLE __HAL_RCC_TIM4_CLK_ENABLE
#define __TIM4_CLK_SLEEP_DISABLE __HAL_RCC_TIM4_CLK_SLEEP_DISABLE
#define __TIM4_CLK_SLEEP_ENABLE __HAL_RCC_TIM4_CLK_SLEEP_ENABLE
#define __TIM4_FORCE_RESET __HAL_RCC_TIM4_FORCE_RESET
#define __TIM4_RELEASE_RESET __HAL_RCC_TIM4_RELEASE_RESET
#define __TIM5_CLK_DISABLE __HAL_RCC_TIM5_CLK_DISABLE
#define __TIM5_CLK_ENABLE __HAL_RCC_TIM5_CLK_ENABLE
#define __TIM5_CLK_SLEEP_DISABLE __HAL_RCC_TIM5_CLK_SLEEP_DISABLE
#define __TIM5_CLK_SLEEP_ENABLE __HAL_RCC_TIM5_CLK_SLEEP_ENABLE
#define __TIM5_FORCE_RESET __HAL_RCC_TIM5_FORCE_RESET
#define __TIM5_RELEASE_RESET __HAL_RCC_TIM5_RELEASE_RESET
#define __TIM6_CLK_DISABLE __HAL_RCC_TIM6_CLK_DISABLE
#define __TIM6_CLK_ENABLE __HAL_RCC_TIM6_CLK_ENABLE
#define __TIM6_CLK_SLEEP_DISABLE __HAL_RCC_TIM6_CLK_SLEEP_DISABLE
#define __TIM6_CLK_SLEEP_ENABLE __HAL_RCC_TIM6_CLK_SLEEP_ENABLE
#define __TIM6_FORCE_RESET __HAL_RCC_TIM6_FORCE_RESET
#define __TIM6_RELEASE_RESET __HAL_RCC_TIM6_RELEASE_RESET
#define __TIM7_CLK_DISABLE __HAL_RCC_TIM7_CLK_DISABLE
#define __TIM7_CLK_ENABLE __HAL_RCC_TIM7_CLK_ENABLE
#define __TIM7_CLK_SLEEP_DISABLE __HAL_RCC_TIM7_CLK_SLEEP_DISABLE
#define __TIM7_CLK_SLEEP_ENABLE __HAL_RCC_TIM7_CLK_SLEEP_ENABLE
#define __TIM7_FORCE_RESET __HAL_RCC_TIM7_FORCE_RESET
#define __TIM7_RELEASE_RESET __HAL_RCC_TIM7_RELEASE_RESET
#define __TIM8_CLK_DISABLE __HAL_RCC_TIM8_CLK_DISABLE
#define __TIM8_CLK_ENABLE __HAL_RCC_TIM8_CLK_ENABLE
#define __TIM8_CLK_SLEEP_DISABLE __HAL_RCC_TIM8_CLK_SLEEP_DISABLE
#define __TIM8_CLK_SLEEP_ENABLE __HAL_RCC_TIM8_CLK_SLEEP_ENABLE
#define __TIM8_FORCE_RESET __HAL_RCC_TIM8_FORCE_RESET
#define __TIM8_RELEASE_RESET __HAL_RCC_TIM8_RELEASE_RESET
#define __TIM9_CLK_DISABLE __HAL_RCC_TIM9_CLK_DISABLE
#define __TIM9_CLK_ENABLE __HAL_RCC_TIM9_CLK_ENABLE
#define __TIM9_FORCE_RESET __HAL_RCC_TIM9_FORCE_RESET
#define __TIM9_RELEASE_RESET __HAL_RCC_TIM9_RELEASE_RESET
#define __TSC_CLK_DISABLE __HAL_RCC_TSC_CLK_DISABLE
#define __TSC_CLK_ENABLE __HAL_RCC_TSC_CLK_ENABLE
#define __TSC_CLK_SLEEP_DISABLE __HAL_RCC_TSC_CLK_SLEEP_DISABLE
#define __TSC_CLK_SLEEP_ENABLE __HAL_RCC_TSC_CLK_SLEEP_ENABLE
#define __TSC_FORCE_RESET __HAL_RCC_TSC_FORCE_RESET
#define __TSC_RELEASE_RESET __HAL_RCC_TSC_RELEASE_RESET
#define __UART4_CLK_DISABLE __HAL_RCC_UART4_CLK_DISABLE
#define __UART4_CLK_ENABLE __HAL_RCC_UART4_CLK_ENABLE
#define __UART4_CLK_SLEEP_DISABLE __HAL_RCC_UART4_CLK_SLEEP_DISABLE
#define __UART4_CLK_SLEEP_ENABLE __HAL_RCC_UART4_CLK_SLEEP_ENABLE
#define __UART4_FORCE_RESET __HAL_RCC_UART4_FORCE_RESET
#define __UART4_RELEASE_RESET __HAL_RCC_UART4_RELEASE_RESET
#define __UART5_CLK_DISABLE __HAL_RCC_UART5_CLK_DISABLE
#define __UART5_CLK_ENABLE __HAL_RCC_UART5_CLK_ENABLE
#define __UART5_CLK_SLEEP_DISABLE __HAL_RCC_UART5_CLK_SLEEP_DISABLE
#define __UART5_CLK_SLEEP_ENABLE __HAL_RCC_UART5_CLK_SLEEP_ENABLE
#define __UART5_FORCE_RESET __HAL_RCC_UART5_FORCE_RESET
#define __UART5_RELEASE_RESET __HAL_RCC_UART5_RELEASE_RESET
#define __USART1_CLK_DISABLE __HAL_RCC_USART1_CLK_DISABLE
#define __USART1_CLK_ENABLE __HAL_RCC_USART1_CLK_ENABLE
#define __USART1_CLK_SLEEP_DISABLE __HAL_RCC_USART1_CLK_SLEEP_DISABLE
#define __USART1_CLK_SLEEP_ENABLE __HAL_RCC_USART1_CLK_SLEEP_ENABLE
#define __USART1_FORCE_RESET __HAL_RCC_USART1_FORCE_RESET
#define __USART1_RELEASE_RESET __HAL_RCC_USART1_RELEASE_RESET
#define __USART2_CLK_DISABLE __HAL_RCC_USART2_CLK_DISABLE
#define __USART2_CLK_ENABLE __HAL_RCC_USART2_CLK_ENABLE
#define __USART2_CLK_SLEEP_DISABLE __HAL_RCC_USART2_CLK_SLEEP_DISABLE
#define __USART2_CLK_SLEEP_ENABLE __HAL_RCC_USART2_CLK_SLEEP_ENABLE
#define __USART2_FORCE_RESET __HAL_RCC_USART2_FORCE_RESET
#define __USART2_RELEASE_RESET __HAL_RCC_USART2_RELEASE_RESET
#define __USART3_CLK_DISABLE __HAL_RCC_USART3_CLK_DISABLE
#define __USART3_CLK_ENABLE __HAL_RCC_USART3_CLK_ENABLE
#define __USART3_CLK_SLEEP_DISABLE __HAL_RCC_USART3_CLK_SLEEP_DISABLE
#define __USART3_CLK_SLEEP_ENABLE __HAL_RCC_USART3_CLK_SLEEP_ENABLE
#define __USART3_FORCE_RESET __HAL_RCC_USART3_FORCE_RESET
#define __USART3_RELEASE_RESET __HAL_RCC_USART3_RELEASE_RESET
#define __USART4_CLK_DISABLE __HAL_RCC_UART4_CLK_DISABLE
#define __USART4_CLK_ENABLE __HAL_RCC_UART4_CLK_ENABLE
#define __USART4_CLK_SLEEP_ENABLE __HAL_RCC_UART4_CLK_SLEEP_ENABLE
#define __USART4_CLK_SLEEP_DISABLE __HAL_RCC_UART4_CLK_SLEEP_DISABLE
#define __USART4_FORCE_RESET __HAL_RCC_UART4_FORCE_RESET
#define __USART4_RELEASE_RESET __HAL_RCC_UART4_RELEASE_RESET
#define __USART5_CLK_DISABLE __HAL_RCC_UART5_CLK_DISABLE
#define __USART5_CLK_ENABLE __HAL_RCC_UART5_CLK_ENABLE
#define __USART5_CLK_SLEEP_ENABLE __HAL_RCC_UART5_CLK_SLEEP_ENABLE
#define __USART5_CLK_SLEEP_DISABLE __HAL_RCC_UART5_CLK_SLEEP_DISABLE
#define __USART5_FORCE_RESET __HAL_RCC_UART5_FORCE_RESET
#define __USART5_RELEASE_RESET __HAL_RCC_UART5_RELEASE_RESET
#define __USART7_CLK_DISABLE __HAL_RCC_UART7_CLK_DISABLE
#define __USART7_CLK_ENABLE __HAL_RCC_UART7_CLK_ENABLE
#define __USART7_FORCE_RESET __HAL_RCC_UART7_FORCE_RESET
#define __USART7_RELEASE_RESET __HAL_RCC_UART7_RELEASE_RESET
#define __USART8_CLK_DISABLE __HAL_RCC_UART8_CLK_DISABLE
#define __USART8_CLK_ENABLE __HAL_RCC_UART8_CLK_ENABLE
#define __USART8_FORCE_RESET __HAL_RCC_UART8_FORCE_RESET
#define __USART8_RELEASE_RESET __HAL_RCC_UART8_RELEASE_RESET
#define __USB_CLK_DISABLE __HAL_RCC_USB_CLK_DISABLE
#define __USB_CLK_ENABLE __HAL_RCC_USB_CLK_ENABLE
#define __USB_FORCE_RESET __HAL_RCC_USB_FORCE_RESET
#define __USB_CLK_SLEEP_ENABLE __HAL_RCC_USB_CLK_SLEEP_ENABLE
#define __USB_CLK_SLEEP_DISABLE __HAL_RCC_USB_CLK_SLEEP_DISABLE
#define __USB_OTG_FS_CLK_DISABLE __HAL_RCC_USB_OTG_FS_CLK_DISABLE
#define __USB_OTG_FS_CLK_ENABLE __HAL_RCC_USB_OTG_FS_CLK_ENABLE
#define __USB_RELEASE_RESET __HAL_RCC_USB_RELEASE_RESET
#define __WWDG_CLK_DISABLE __HAL_RCC_WWDG_CLK_DISABLE
#define __WWDG_CLK_ENABLE __HAL_RCC_WWDG_CLK_ENABLE
#define __WWDG_CLK_SLEEP_DISABLE __HAL_RCC_WWDG_CLK_SLEEP_DISABLE
#define __WWDG_CLK_SLEEP_ENABLE __HAL_RCC_WWDG_CLK_SLEEP_ENABLE
#define __WWDG_FORCE_RESET __HAL_RCC_WWDG_FORCE_RESET
#define __WWDG_RELEASE_RESET __HAL_RCC_WWDG_RELEASE_RESET
#define __TIM21_CLK_ENABLE __HAL_RCC_TIM21_CLK_ENABLE
#define __TIM21_CLK_DISABLE __HAL_RCC_TIM21_CLK_DISABLE
#define __TIM21_FORCE_RESET __HAL_RCC_TIM21_FORCE_RESET
#define __TIM21_RELEASE_RESET __HAL_RCC_TIM21_RELEASE_RESET
#define __TIM21_CLK_SLEEP_ENABLE __HAL_RCC_TIM21_CLK_SLEEP_ENABLE
#define __TIM21_CLK_SLEEP_DISABLE __HAL_RCC_TIM21_CLK_SLEEP_DISABLE
#define __TIM22_CLK_ENABLE __HAL_RCC_TIM22_CLK_ENABLE
#define __TIM22_CLK_DISABLE __HAL_RCC_TIM22_CLK_DISABLE
#define __TIM22_FORCE_RESET __HAL_RCC_TIM22_FORCE_RESET
#define __TIM22_RELEASE_RESET __HAL_RCC_TIM22_RELEASE_RESET
#define __TIM22_CLK_SLEEP_ENABLE __HAL_RCC_TIM22_CLK_SLEEP_ENABLE
#define __TIM22_CLK_SLEEP_DISABLE __HAL_RCC_TIM22_CLK_SLEEP_DISABLE
#define __CRS_CLK_DISABLE __HAL_RCC_CRS_CLK_DISABLE
#define __CRS_CLK_ENABLE __HAL_RCC_CRS_CLK_ENABLE
#define __CRS_CLK_SLEEP_DISABLE __HAL_RCC_CRS_CLK_SLEEP_DISABLE
#define __CRS_CLK_SLEEP_ENABLE __HAL_RCC_CRS_CLK_SLEEP_ENABLE
#define __CRS_FORCE_RESET __HAL_RCC_CRS_FORCE_RESET
#define __CRS_RELEASE_RESET __HAL_RCC_CRS_RELEASE_RESET
#define __RCC_BACKUPRESET_FORCE __HAL_RCC_BACKUPRESET_FORCE
#define __RCC_BACKUPRESET_RELEASE __HAL_RCC_BACKUPRESET_RELEASE
#define __USB_OTG_FS_FORCE_RESET __HAL_RCC_USB_OTG_FS_FORCE_RESET
#define __USB_OTG_FS_RELEASE_RESET __HAL_RCC_USB_OTG_FS_RELEASE_RESET
#define __USB_OTG_FS_CLK_SLEEP_ENABLE __HAL_RCC_USB_OTG_FS_CLK_SLEEP_ENABLE
#define __USB_OTG_FS_CLK_SLEEP_DISABLE __HAL_RCC_USB_OTG_FS_CLK_SLEEP_DISABLE
#define __USB_OTG_HS_CLK_DISABLE __HAL_RCC_USB_OTG_HS_CLK_DISABLE
#define __USB_OTG_HS_CLK_ENABLE __HAL_RCC_USB_OTG_HS_CLK_ENABLE
#define __USB_OTG_HS_ULPI_CLK_ENABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE
#define __USB_OTG_HS_ULPI_CLK_DISABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_DISABLE
#define __TIM9_CLK_SLEEP_ENABLE __HAL_RCC_TIM9_CLK_SLEEP_ENABLE
#define __TIM9_CLK_SLEEP_DISABLE __HAL_RCC_TIM9_CLK_SLEEP_DISABLE
#define __TIM10_CLK_SLEEP_ENABLE __HAL_RCC_TIM10_CLK_SLEEP_ENABLE
#define __TIM10_CLK_SLEEP_DISABLE __HAL_RCC_TIM10_CLK_SLEEP_DISABLE
#define __TIM11_CLK_SLEEP_ENABLE __HAL_RCC_TIM11_CLK_SLEEP_ENABLE
#define __TIM11_CLK_SLEEP_DISABLE __HAL_RCC_TIM11_CLK_SLEEP_DISABLE
#define __ETHMACPTP_CLK_SLEEP_ENABLE __HAL_RCC_ETHMACPTP_CLK_SLEEP_ENABLE
#define __ETHMACPTP_CLK_SLEEP_DISABLE __HAL_RCC_ETHMACPTP_CLK_SLEEP_DISABLE
#define __ETHMACPTP_CLK_ENABLE __HAL_RCC_ETHMACPTP_CLK_ENABLE
#define __ETHMACPTP_CLK_DISABLE __HAL_RCC_ETHMACPTP_CLK_DISABLE
#define __HASH_CLK_ENABLE __HAL_RCC_HASH_CLK_ENABLE
#define __HASH_FORCE_RESET __HAL_RCC_HASH_FORCE_RESET
#define __HASH_RELEASE_RESET __HAL_RCC_HASH_RELEASE_RESET
#define __HASH_CLK_SLEEP_ENABLE __HAL_RCC_HASH_CLK_SLEEP_ENABLE
#define __HASH_CLK_SLEEP_DISABLE __HAL_RCC_HASH_CLK_SLEEP_DISABLE
#define __HASH_CLK_DISABLE __HAL_RCC_HASH_CLK_DISABLE
#define __SPI5_CLK_ENABLE __HAL_RCC_SPI5_CLK_ENABLE
#define __SPI5_CLK_DISABLE __HAL_RCC_SPI5_CLK_DISABLE
#define __SPI5_FORCE_RESET __HAL_RCC_SPI5_FORCE_RESET
#define __SPI5_RELEASE_RESET __HAL_RCC_SPI5_RELEASE_RESET
#define __SPI5_CLK_SLEEP_ENABLE __HAL_RCC_SPI5_CLK_SLEEP_ENABLE
#define __SPI5_CLK_SLEEP_DISABLE __HAL_RCC_SPI5_CLK_SLEEP_DISABLE
#define __SPI6_CLK_ENABLE __HAL_RCC_SPI6_CLK_ENABLE
#define __SPI6_CLK_DISABLE __HAL_RCC_SPI6_CLK_DISABLE
#define __SPI6_FORCE_RESET __HAL_RCC_SPI6_FORCE_RESET
#define __SPI6_RELEASE_RESET __HAL_RCC_SPI6_RELEASE_RESET
#define __SPI6_CLK_SLEEP_ENABLE __HAL_RCC_SPI6_CLK_SLEEP_ENABLE
#define __SPI6_CLK_SLEEP_DISABLE __HAL_RCC_SPI6_CLK_SLEEP_DISABLE
#define __LTDC_CLK_ENABLE __HAL_RCC_LTDC_CLK_ENABLE
#define __LTDC_CLK_DISABLE __HAL_RCC_LTDC_CLK_DISABLE
#define __LTDC_FORCE_RESET __HAL_RCC_LTDC_FORCE_RESET
#define __LTDC_RELEASE_RESET __HAL_RCC_LTDC_RELEASE_RESET
#define __LTDC_CLK_SLEEP_ENABLE __HAL_RCC_LTDC_CLK_SLEEP_ENABLE
#define __ETHMAC_CLK_SLEEP_ENABLE __HAL_RCC_ETHMAC_CLK_SLEEP_ENABLE
#define __ETHMAC_CLK_SLEEP_DISABLE __HAL_RCC_ETHMAC_CLK_SLEEP_DISABLE
#define __ETHMACTX_CLK_SLEEP_ENABLE __HAL_RCC_ETHMACTX_CLK_SLEEP_ENABLE
#define __ETHMACTX_CLK_SLEEP_DISABLE __HAL_RCC_ETHMACTX_CLK_SLEEP_DISABLE
#define __ETHMACRX_CLK_SLEEP_ENABLE __HAL_RCC_ETHMACRX_CLK_SLEEP_ENABLE
#define __ETHMACRX_CLK_SLEEP_DISABLE __HAL_RCC_ETHMACRX_CLK_SLEEP_DISABLE
#define __TIM12_CLK_SLEEP_ENABLE __HAL_RCC_TIM12_CLK_SLEEP_ENABLE
#define __TIM12_CLK_SLEEP_DISABLE __HAL_RCC_TIM12_CLK_SLEEP_DISABLE
#define __TIM13_CLK_SLEEP_ENABLE __HAL_RCC_TIM13_CLK_SLEEP_ENABLE
#define __TIM13_CLK_SLEEP_DISABLE __HAL_RCC_TIM13_CLK_SLEEP_DISABLE
#define __TIM14_CLK_SLEEP_ENABLE __HAL_RCC_TIM14_CLK_SLEEP_ENABLE
#define __TIM14_CLK_SLEEP_DISABLE __HAL_RCC_TIM14_CLK_SLEEP_DISABLE
#define __BKPSRAM_CLK_ENABLE __HAL_RCC_BKPSRAM_CLK_ENABLE
#define __BKPSRAM_CLK_DISABLE __HAL_RCC_BKPSRAM_CLK_DISABLE
#define __BKPSRAM_CLK_SLEEP_ENABLE __HAL_RCC_BKPSRAM_CLK_SLEEP_ENABLE
#define __BKPSRAM_CLK_SLEEP_DISABLE __HAL_RCC_BKPSRAM_CLK_SLEEP_DISABLE
#define __CCMDATARAMEN_CLK_ENABLE __HAL_RCC_CCMDATARAMEN_CLK_ENABLE
#define __CCMDATARAMEN_CLK_DISABLE __HAL_RCC_CCMDATARAMEN_CLK_DISABLE
#define __USART6_CLK_ENABLE __HAL_RCC_USART6_CLK_ENABLE
#define __USART6_CLK_DISABLE __HAL_RCC_USART6_CLK_DISABLE
#define __USART6_FORCE_RESET __HAL_RCC_USART6_FORCE_RESET
#define __USART6_RELEASE_RESET __HAL_RCC_USART6_RELEASE_RESET
#define __USART6_CLK_SLEEP_ENABLE __HAL_RCC_USART6_CLK_SLEEP_ENABLE
#define __USART6_CLK_SLEEP_DISABLE __HAL_RCC_USART6_CLK_SLEEP_DISABLE
#define __SPI4_CLK_ENABLE __HAL_RCC_SPI4_CLK_ENABLE
#define __SPI4_CLK_DISABLE __HAL_RCC_SPI4_CLK_DISABLE
#define __SPI4_FORCE_RESET __HAL_RCC_SPI4_FORCE_RESET
#define __SPI4_RELEASE_RESET __HAL_RCC_SPI4_RELEASE_RESET
#define __SPI4_CLK_SLEEP_ENABLE __HAL_RCC_SPI4_CLK_SLEEP_ENABLE
#define __SPI4_CLK_SLEEP_DISABLE __HAL_RCC_SPI4_CLK_SLEEP_DISABLE
#define __GPIOI_CLK_ENABLE __HAL_RCC_GPIOI_CLK_ENABLE
#define __GPIOI_CLK_DISABLE __HAL_RCC_GPIOI_CLK_DISABLE
#define __GPIOI_FORCE_RESET __HAL_RCC_GPIOI_FORCE_RESET
#define __GPIOI_RELEASE_RESET __HAL_RCC_GPIOI_RELEASE_RESET
#define __GPIOI_CLK_SLEEP_ENABLE __HAL_RCC_GPIOI_CLK_SLEEP_ENABLE
#define __GPIOI_CLK_SLEEP_DISABLE __HAL_RCC_GPIOI_CLK_SLEEP_DISABLE
#define __GPIOJ_CLK_ENABLE __HAL_RCC_GPIOJ_CLK_ENABLE
#define __GPIOJ_CLK_DISABLE __HAL_RCC_GPIOJ_CLK_DISABLE
#define __GPIOJ_FORCE_RESET __HAL_RCC_GPIOJ_FORCE_RESET
#define __GPIOJ_RELEASE_RESET __HAL_RCC_GPIOJ_RELEASE_RESET
#define __GPIOJ_CLK_SLEEP_ENABLE __HAL_RCC_GPIOJ_CLK_SLEEP_ENABLE
#define __GPIOJ_CLK_SLEEP_DISABLE __HAL_RCC_GPIOJ_CLK_SLEEP_DISABLE
#define __GPIOK_CLK_ENABLE __HAL_RCC_GPIOK_CLK_ENABLE
#define __GPIOK_CLK_DISABLE __HAL_RCC_GPIOK_CLK_DISABLE
#define __GPIOK_RELEASE_RESET __HAL_RCC_GPIOK_RELEASE_RESET
#define __GPIOK_CLK_SLEEP_ENABLE __HAL_RCC_GPIOK_CLK_SLEEP_ENABLE
#define __GPIOK_CLK_SLEEP_DISABLE __HAL_RCC_GPIOK_CLK_SLEEP_DISABLE
#define __ETH_CLK_ENABLE __HAL_RCC_ETH_CLK_ENABLE
#define __ETH_CLK_DISABLE __HAL_RCC_ETH_CLK_DISABLE
#define __DCMI_CLK_ENABLE __HAL_RCC_DCMI_CLK_ENABLE
#define __DCMI_CLK_DISABLE __HAL_RCC_DCMI_CLK_DISABLE
#define __DCMI_FORCE_RESET __HAL_RCC_DCMI_FORCE_RESET
#define __DCMI_RELEASE_RESET __HAL_RCC_DCMI_RELEASE_RESET
#define __DCMI_CLK_SLEEP_ENABLE __HAL_RCC_DCMI_CLK_SLEEP_ENABLE
#define __DCMI_CLK_SLEEP_DISABLE __HAL_RCC_DCMI_CLK_SLEEP_DISABLE
#define __UART7_CLK_ENABLE __HAL_RCC_UART7_CLK_ENABLE
#define __UART7_CLK_DISABLE __HAL_RCC_UART7_CLK_DISABLE
#define __UART7_RELEASE_RESET __HAL_RCC_UART7_RELEASE_RESET
#define __UART7_FORCE_RESET __HAL_RCC_UART7_FORCE_RESET
#define __UART7_CLK_SLEEP_ENABLE __HAL_RCC_UART7_CLK_SLEEP_ENABLE
#define __UART7_CLK_SLEEP_DISABLE __HAL_RCC_UART7_CLK_SLEEP_DISABLE
#define __UART8_CLK_ENABLE __HAL_RCC_UART8_CLK_ENABLE
#define __UART8_CLK_DISABLE __HAL_RCC_UART8_CLK_DISABLE
#define __UART8_FORCE_RESET __HAL_RCC_UART8_FORCE_RESET
#define __UART8_RELEASE_RESET __HAL_RCC_UART8_RELEASE_RESET
#define __UART8_CLK_SLEEP_ENABLE __HAL_RCC_UART8_CLK_SLEEP_ENABLE
#define __UART8_CLK_SLEEP_DISABLE __HAL_RCC_UART8_CLK_SLEEP_DISABLE
#define __OTGHS_CLK_SLEEP_ENABLE __HAL_RCC_USB_OTG_HS_CLK_SLEEP_ENABLE
#define __OTGHS_CLK_SLEEP_DISABLE __HAL_RCC_USB_OTG_HS_CLK_SLEEP_DISABLE
#define __OTGHS_FORCE_RESET __HAL_RCC_USB_OTG_HS_FORCE_RESET
#define __OTGHS_RELEASE_RESET __HAL_RCC_USB_OTG_HS_RELEASE_RESET
#define __OTGHSULPI_CLK_SLEEP_ENABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_ENABLE
#define __OTGHSULPI_CLK_SLEEP_DISABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_DISABLE
#define __HAL_RCC_OTGHS_CLK_SLEEP_ENABLE __HAL_RCC_USB_OTG_HS_CLK_SLEEP_ENABLE
#define __HAL_RCC_OTGHS_CLK_SLEEP_DISABLE __HAL_RCC_USB_OTG_HS_CLK_SLEEP_DISABLE
#define __HAL_RCC_OTGHS_IS_CLK_SLEEP_ENABLED __HAL_RCC_USB_OTG_HS_IS_CLK_SLEEP_ENABLED
#define __HAL_RCC_OTGHS_IS_CLK_SLEEP_DISABLED __HAL_RCC_USB_OTG_HS_IS_CLK_SLEEP_DISABLED
#define __HAL_RCC_OTGHS_FORCE_RESET __HAL_RCC_USB_OTG_HS_FORCE_RESET
#define __HAL_RCC_OTGHS_RELEASE_RESET __HAL_RCC_USB_OTG_HS_RELEASE_RESET
#define __HAL_RCC_OTGHSULPI_CLK_SLEEP_ENABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_ENABLE
#define __HAL_RCC_OTGHSULPI_CLK_SLEEP_DISABLE __HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_DISABLE
#define __HAL_RCC_OTGHSULPI_IS_CLK_SLEEP_ENABLED __HAL_RCC_USB_OTG_HS_ULPI_IS_CLK_SLEEP_ENABLED
#define __HAL_RCC_OTGHSULPI_IS_CLK_SLEEP_DISABLED __HAL_RCC_USB_OTG_HS_ULPI_IS_CLK_SLEEP_DISABLED
#define __SRAM3_CLK_SLEEP_ENABLE __HAL_RCC_SRAM3_CLK_SLEEP_ENABLE
#define __CAN2_CLK_SLEEP_ENABLE __HAL_RCC_CAN2_CLK_SLEEP_ENABLE
#define __CAN2_CLK_SLEEP_DISABLE __HAL_RCC_CAN2_CLK_SLEEP_DISABLE
#define __DAC_CLK_SLEEP_ENABLE __HAL_RCC_DAC_CLK_SLEEP_ENABLE
#define __DAC_CLK_SLEEP_DISABLE __HAL_RCC_DAC_CLK_SLEEP_DISABLE
#define __ADC2_CLK_SLEEP_ENABLE __HAL_RCC_ADC2_CLK_SLEEP_ENABLE
#define __ADC2_CLK_SLEEP_DISABLE __HAL_RCC_ADC2_CLK_SLEEP_DISABLE
#define __ADC3_CLK_SLEEP_ENABLE __HAL_RCC_ADC3_CLK_SLEEP_ENABLE
#define __ADC3_CLK_SLEEP_DISABLE __HAL_RCC_ADC3_CLK_SLEEP_DISABLE
#define __FSMC_FORCE_RESET __HAL_RCC_FSMC_FORCE_RESET
#define __FSMC_RELEASE_RESET __HAL_RCC_FSMC_RELEASE_RESET
#define __FSMC_CLK_SLEEP_ENABLE __HAL_RCC_FSMC_CLK_SLEEP_ENABLE
#define __FSMC_CLK_SLEEP_DISABLE __HAL_RCC_FSMC_CLK_SLEEP_DISABLE
#define __SDIO_FORCE_RESET __HAL_RCC_SDIO_FORCE_RESET
#define __SDIO_RELEASE_RESET __HAL_RCC_SDIO_RELEASE_RESET
#define __SDIO_CLK_SLEEP_DISABLE __HAL_RCC_SDIO_CLK_SLEEP_DISABLE
#define __SDIO_CLK_SLEEP_ENABLE __HAL_RCC_SDIO_CLK_SLEEP_ENABLE
#define __DMA2D_CLK_ENABLE __HAL_RCC_DMA2D_CLK_ENABLE
#define __DMA2D_CLK_DISABLE __HAL_RCC_DMA2D_CLK_DISABLE
#define __DMA2D_FORCE_RESET __HAL_RCC_DMA2D_FORCE_RESET
#define __DMA2D_RELEASE_RESET __HAL_RCC_DMA2D_RELEASE_RESET
#define __DMA2D_CLK_SLEEP_ENABLE __HAL_RCC_DMA2D_CLK_SLEEP_ENABLE
#define __DMA2D_CLK_SLEEP_DISABLE __HAL_RCC_DMA2D_CLK_SLEEP_DISABLE
/* alias define maintained for legacy */
#define __HAL_RCC_OTGFS_FORCE_RESET __HAL_RCC_USB_OTG_FS_FORCE_RESET
#define __HAL_RCC_OTGFS_RELEASE_RESET __HAL_RCC_USB_OTG_FS_RELEASE_RESET
#define __ADC12_CLK_ENABLE __HAL_RCC_ADC12_CLK_ENABLE
#define __ADC12_CLK_DISABLE __HAL_RCC_ADC12_CLK_DISABLE
#define __ADC34_CLK_ENABLE __HAL_RCC_ADC34_CLK_ENABLE
#define __ADC34_CLK_DISABLE __HAL_RCC_ADC34_CLK_DISABLE
#define __DAC2_CLK_ENABLE __HAL_RCC_DAC2_CLK_ENABLE
#define __DAC2_CLK_DISABLE __HAL_RCC_DAC2_CLK_DISABLE
#define __TIM18_CLK_ENABLE __HAL_RCC_TIM18_CLK_ENABLE
#define __TIM18_CLK_DISABLE __HAL_RCC_TIM18_CLK_DISABLE
#define __TIM19_CLK_ENABLE __HAL_RCC_TIM19_CLK_ENABLE
#define __TIM19_CLK_DISABLE __HAL_RCC_TIM19_CLK_DISABLE
#define __TIM20_CLK_ENABLE __HAL_RCC_TIM20_CLK_ENABLE
#define __TIM20_CLK_DISABLE __HAL_RCC_TIM20_CLK_DISABLE
#define __HRTIM1_CLK_ENABLE __HAL_RCC_HRTIM1_CLK_ENABLE
#define __HRTIM1_CLK_DISABLE __HAL_RCC_HRTIM1_CLK_DISABLE
#define __SDADC1_CLK_ENABLE __HAL_RCC_SDADC1_CLK_ENABLE
#define __SDADC2_CLK_ENABLE __HAL_RCC_SDADC2_CLK_ENABLE
#define __SDADC3_CLK_ENABLE __HAL_RCC_SDADC3_CLK_ENABLE
#define __SDADC1_CLK_DISABLE __HAL_RCC_SDADC1_CLK_DISABLE
#define __SDADC2_CLK_DISABLE __HAL_RCC_SDADC2_CLK_DISABLE
#define __SDADC3_CLK_DISABLE __HAL_RCC_SDADC3_CLK_DISABLE
#define __ADC12_FORCE_RESET __HAL_RCC_ADC12_FORCE_RESET
#define __ADC12_RELEASE_RESET __HAL_RCC_ADC12_RELEASE_RESET
#define __ADC34_FORCE_RESET __HAL_RCC_ADC34_FORCE_RESET
#define __ADC34_RELEASE_RESET __HAL_RCC_ADC34_RELEASE_RESET
#define __DAC2_FORCE_RESET __HAL_RCC_DAC2_FORCE_RESET
#define __DAC2_RELEASE_RESET __HAL_RCC_DAC2_RELEASE_RESET
#define __TIM18_FORCE_RESET __HAL_RCC_TIM18_FORCE_RESET
#define __TIM18_RELEASE_RESET __HAL_RCC_TIM18_RELEASE_RESET
#define __TIM19_FORCE_RESET __HAL_RCC_TIM19_FORCE_RESET
#define __TIM19_RELEASE_RESET __HAL_RCC_TIM19_RELEASE_RESET
#define __TIM20_FORCE_RESET __HAL_RCC_TIM20_FORCE_RESET
#define __TIM20_RELEASE_RESET __HAL_RCC_TIM20_RELEASE_RESET
#define __HRTIM1_FORCE_RESET __HAL_RCC_HRTIM1_FORCE_RESET
#define __HRTIM1_RELEASE_RESET __HAL_RCC_HRTIM1_RELEASE_RESET
#define __SDADC1_FORCE_RESET __HAL_RCC_SDADC1_FORCE_RESET
#define __SDADC2_FORCE_RESET __HAL_RCC_SDADC2_FORCE_RESET
#define __SDADC3_FORCE_RESET __HAL_RCC_SDADC3_FORCE_RESET
#define __SDADC1_RELEASE_RESET __HAL_RCC_SDADC1_RELEASE_RESET
#define __SDADC2_RELEASE_RESET __HAL_RCC_SDADC2_RELEASE_RESET
#define __SDADC3_RELEASE_RESET __HAL_RCC_SDADC3_RELEASE_RESET
#define __ADC1_IS_CLK_ENABLED __HAL_RCC_ADC1_IS_CLK_ENABLED
#define __ADC1_IS_CLK_DISABLED __HAL_RCC_ADC1_IS_CLK_DISABLED
#define __ADC12_IS_CLK_ENABLED __HAL_RCC_ADC12_IS_CLK_ENABLED
#define __ADC12_IS_CLK_DISABLED __HAL_RCC_ADC12_IS_CLK_DISABLED
#define __ADC34_IS_CLK_ENABLED __HAL_RCC_ADC34_IS_CLK_ENABLED
#define __ADC34_IS_CLK_DISABLED __HAL_RCC_ADC34_IS_CLK_DISABLED
#define __CEC_IS_CLK_ENABLED __HAL_RCC_CEC_IS_CLK_ENABLED
#define __CEC_IS_CLK_DISABLED __HAL_RCC_CEC_IS_CLK_DISABLED
#define __CRC_IS_CLK_ENABLED __HAL_RCC_CRC_IS_CLK_ENABLED
#define __CRC_IS_CLK_DISABLED __HAL_RCC_CRC_IS_CLK_DISABLED
#define __DAC1_IS_CLK_ENABLED __HAL_RCC_DAC1_IS_CLK_ENABLED
#define __DAC1_IS_CLK_DISABLED __HAL_RCC_DAC1_IS_CLK_DISABLED
#define __DAC2_IS_CLK_ENABLED __HAL_RCC_DAC2_IS_CLK_ENABLED
#define __DAC2_IS_CLK_DISABLED __HAL_RCC_DAC2_IS_CLK_DISABLED
#define __DMA1_IS_CLK_ENABLED __HAL_RCC_DMA1_IS_CLK_ENABLED
#define __DMA1_IS_CLK_DISABLED __HAL_RCC_DMA1_IS_CLK_DISABLED
#define __DMA2_IS_CLK_ENABLED __HAL_RCC_DMA2_IS_CLK_ENABLED
#define __DMA2_IS_CLK_DISABLED __HAL_RCC_DMA2_IS_CLK_DISABLED
#define __FLITF_IS_CLK_ENABLED __HAL_RCC_FLITF_IS_CLK_ENABLED
#define __FLITF_IS_CLK_DISABLED __HAL_RCC_FLITF_IS_CLK_DISABLED
#define __FMC_IS_CLK_ENABLED __HAL_RCC_FMC_IS_CLK_ENABLED
#define __FMC_IS_CLK_DISABLED __HAL_RCC_FMC_IS_CLK_DISABLED
#define __GPIOA_IS_CLK_ENABLED __HAL_RCC_GPIOA_IS_CLK_ENABLED
#define __GPIOA_IS_CLK_DISABLED __HAL_RCC_GPIOA_IS_CLK_DISABLED
#define __GPIOB_IS_CLK_ENABLED __HAL_RCC_GPIOB_IS_CLK_ENABLED
#define __GPIOB_IS_CLK_DISABLED __HAL_RCC_GPIOB_IS_CLK_DISABLED
#define __GPIOC_IS_CLK_ENABLED __HAL_RCC_GPIOC_IS_CLK_ENABLED
#define __GPIOC_IS_CLK_DISABLED __HAL_RCC_GPIOC_IS_CLK_DISABLED
#define __GPIOD_IS_CLK_ENABLED __HAL_RCC_GPIOD_IS_CLK_ENABLED
#define __GPIOD_IS_CLK_DISABLED __HAL_RCC_GPIOD_IS_CLK_DISABLED
#define __GPIOE_IS_CLK_ENABLED __HAL_RCC_GPIOE_IS_CLK_ENABLED
#define __GPIOE_IS_CLK_DISABLED __HAL_RCC_GPIOE_IS_CLK_DISABLED
#define __GPIOF_IS_CLK_ENABLED __HAL_RCC_GPIOF_IS_CLK_ENABLED
#define __GPIOF_IS_CLK_DISABLED __HAL_RCC_GPIOF_IS_CLK_DISABLED
#define __GPIOG_IS_CLK_ENABLED __HAL_RCC_GPIOG_IS_CLK_ENABLED
#define __GPIOG_IS_CLK_DISABLED __HAL_RCC_GPIOG_IS_CLK_DISABLED
#define __GPIOH_IS_CLK_ENABLED __HAL_RCC_GPIOH_IS_CLK_ENABLED
#define __GPIOH_IS_CLK_DISABLED __HAL_RCC_GPIOH_IS_CLK_DISABLED
#define __HRTIM1_IS_CLK_ENABLED __HAL_RCC_HRTIM1_IS_CLK_ENABLED
#define __HRTIM1_IS_CLK_DISABLED __HAL_RCC_HRTIM1_IS_CLK_DISABLED
#define __I2C1_IS_CLK_ENABLED __HAL_RCC_I2C1_IS_CLK_ENABLED
#define __I2C1_IS_CLK_DISABLED __HAL_RCC_I2C1_IS_CLK_DISABLED
#define __I2C2_IS_CLK_ENABLED __HAL_RCC_I2C2_IS_CLK_ENABLED
#define __I2C2_IS_CLK_DISABLED __HAL_RCC_I2C2_IS_CLK_DISABLED
#define __I2C3_IS_CLK_ENABLED __HAL_RCC_I2C3_IS_CLK_ENABLED
#define __I2C3_IS_CLK_DISABLED __HAL_RCC_I2C3_IS_CLK_DISABLED
#define __PWR_IS_CLK_ENABLED __HAL_RCC_PWR_IS_CLK_ENABLED
#define __PWR_IS_CLK_DISABLED __HAL_RCC_PWR_IS_CLK_DISABLED
#define __SYSCFG_IS_CLK_ENABLED __HAL_RCC_SYSCFG_IS_CLK_ENABLED
#define __SYSCFG_IS_CLK_DISABLED __HAL_RCC_SYSCFG_IS_CLK_DISABLED
#define __SPI1_IS_CLK_ENABLED __HAL_RCC_SPI1_IS_CLK_ENABLED
#define __SPI1_IS_CLK_DISABLED __HAL_RCC_SPI1_IS_CLK_DISABLED
#define __SPI2_IS_CLK_ENABLED __HAL_RCC_SPI2_IS_CLK_ENABLED
#define __SPI2_IS_CLK_DISABLED __HAL_RCC_SPI2_IS_CLK_DISABLED
#define __SPI3_IS_CLK_ENABLED __HAL_RCC_SPI3_IS_CLK_ENABLED
#define __SPI3_IS_CLK_DISABLED __HAL_RCC_SPI3_IS_CLK_DISABLED
#define __SPI4_IS_CLK_ENABLED __HAL_RCC_SPI4_IS_CLK_ENABLED
#define __SPI4_IS_CLK_DISABLED __HAL_RCC_SPI4_IS_CLK_DISABLED
#define __SDADC1_IS_CLK_ENABLED __HAL_RCC_SDADC1_IS_CLK_ENABLED
#define __SDADC1_IS_CLK_DISABLED __HAL_RCC_SDADC1_IS_CLK_DISABLED
#define __SDADC2_IS_CLK_ENABLED __HAL_RCC_SDADC2_IS_CLK_ENABLED
#define __SDADC2_IS_CLK_DISABLED __HAL_RCC_SDADC2_IS_CLK_DISABLED
#define __SDADC3_IS_CLK_ENABLED __HAL_RCC_SDADC3_IS_CLK_ENABLED
#define __SDADC3_IS_CLK_DISABLED __HAL_RCC_SDADC3_IS_CLK_DISABLED
#define __SRAM_IS_CLK_ENABLED __HAL_RCC_SRAM_IS_CLK_ENABLED
#define __SRAM_IS_CLK_DISABLED __HAL_RCC_SRAM_IS_CLK_DISABLED
#define __TIM1_IS_CLK_ENABLED __HAL_RCC_TIM1_IS_CLK_ENABLED
#define __TIM1_IS_CLK_DISABLED __HAL_RCC_TIM1_IS_CLK_DISABLED
#define __TIM2_IS_CLK_ENABLED __HAL_RCC_TIM2_IS_CLK_ENABLED
#define __TIM2_IS_CLK_DISABLED __HAL_RCC_TIM2_IS_CLK_DISABLED
#define __TIM3_IS_CLK_ENABLED __HAL_RCC_TIM3_IS_CLK_ENABLED
#define __TIM3_IS_CLK_DISABLED __HAL_RCC_TIM3_IS_CLK_DISABLED
#define __TIM4_IS_CLK_ENABLED __HAL_RCC_TIM4_IS_CLK_ENABLED
#define __TIM4_IS_CLK_DISABLED __HAL_RCC_TIM4_IS_CLK_DISABLED
#define __TIM5_IS_CLK_ENABLED __HAL_RCC_TIM5_IS_CLK_ENABLED
#define __TIM5_IS_CLK_DISABLED __HAL_RCC_TIM5_IS_CLK_DISABLED
#define __TIM6_IS_CLK_ENABLED __HAL_RCC_TIM6_IS_CLK_ENABLED
#define __TIM6_IS_CLK_DISABLED __HAL_RCC_TIM6_IS_CLK_DISABLED
#define __TIM7_IS_CLK_ENABLED __HAL_RCC_TIM7_IS_CLK_ENABLED
#define __TIM7_IS_CLK_DISABLED __HAL_RCC_TIM7_IS_CLK_DISABLED
#define __TIM8_IS_CLK_ENABLED __HAL_RCC_TIM8_IS_CLK_ENABLED
#define __TIM8_IS_CLK_DISABLED __HAL_RCC_TIM8_IS_CLK_DISABLED
#define __TIM12_IS_CLK_ENABLED __HAL_RCC_TIM12_IS_CLK_ENABLED
#define __TIM12_IS_CLK_DISABLED __HAL_RCC_TIM12_IS_CLK_DISABLED
#define __TIM13_IS_CLK_ENABLED __HAL_RCC_TIM13_IS_CLK_ENABLED
#define __TIM13_IS_CLK_DISABLED __HAL_RCC_TIM13_IS_CLK_DISABLED
#define __TIM14_IS_CLK_ENABLED __HAL_RCC_TIM14_IS_CLK_ENABLED
#define __TIM14_IS_CLK_DISABLED __HAL_RCC_TIM14_IS_CLK_DISABLED
#define __TIM15_IS_CLK_ENABLED __HAL_RCC_TIM15_IS_CLK_ENABLED
#define __TIM15_IS_CLK_DISABLED __HAL_RCC_TIM15_IS_CLK_DISABLED
#define __TIM16_IS_CLK_ENABLED __HAL_RCC_TIM16_IS_CLK_ENABLED
#define __TIM16_IS_CLK_DISABLED __HAL_RCC_TIM16_IS_CLK_DISABLED
#define __TIM17_IS_CLK_ENABLED __HAL_RCC_TIM17_IS_CLK_ENABLED
#define __TIM17_IS_CLK_DISABLED __HAL_RCC_TIM17_IS_CLK_DISABLED
#define __TIM18_IS_CLK_ENABLED __HAL_RCC_TIM18_IS_CLK_ENABLED
#define __TIM18_IS_CLK_DISABLED __HAL_RCC_TIM18_IS_CLK_DISABLED
#define __TIM19_IS_CLK_ENABLED __HAL_RCC_TIM19_IS_CLK_ENABLED
#define __TIM19_IS_CLK_DISABLED __HAL_RCC_TIM19_IS_CLK_DISABLED
#define __TIM20_IS_CLK_ENABLED __HAL_RCC_TIM20_IS_CLK_ENABLED
#define __TIM20_IS_CLK_DISABLED __HAL_RCC_TIM20_IS_CLK_DISABLED
#define __TSC_IS_CLK_ENABLED __HAL_RCC_TSC_IS_CLK_ENABLED
#define __TSC_IS_CLK_DISABLED __HAL_RCC_TSC_IS_CLK_DISABLED
#define __UART4_IS_CLK_ENABLED __HAL_RCC_UART4_IS_CLK_ENABLED
#define __UART4_IS_CLK_DISABLED __HAL_RCC_UART4_IS_CLK_DISABLED
#define __UART5_IS_CLK_ENABLED __HAL_RCC_UART5_IS_CLK_ENABLED
#define __UART5_IS_CLK_DISABLED __HAL_RCC_UART5_IS_CLK_DISABLED
#define __USART1_IS_CLK_ENABLED __HAL_RCC_USART1_IS_CLK_ENABLED
#define __USART1_IS_CLK_DISABLED __HAL_RCC_USART1_IS_CLK_DISABLED
#define __USART2_IS_CLK_ENABLED __HAL_RCC_USART2_IS_CLK_ENABLED
#define __USART2_IS_CLK_DISABLED __HAL_RCC_USART2_IS_CLK_DISABLED
#define __USART3_IS_CLK_ENABLED __HAL_RCC_USART3_IS_CLK_ENABLED
#define __USART3_IS_CLK_DISABLED __HAL_RCC_USART3_IS_CLK_DISABLED
#define __USB_IS_CLK_ENABLED __HAL_RCC_USB_IS_CLK_ENABLED
#define __USB_IS_CLK_DISABLED __HAL_RCC_USB_IS_CLK_DISABLED
#define __WWDG_IS_CLK_ENABLED __HAL_RCC_WWDG_IS_CLK_ENABLED
#define __WWDG_IS_CLK_DISABLED __HAL_RCC_WWDG_IS_CLK_DISABLED
#if defined(STM32F4)
#define __HAL_RCC_SDMMC1_FORCE_RESET __HAL_RCC_SDIO_FORCE_RESET
#define __HAL_RCC_SDMMC1_RELEASE_RESET __HAL_RCC_SDIO_RELEASE_RESET
#define __HAL_RCC_SDMMC1_CLK_SLEEP_ENABLE __HAL_RCC_SDIO_CLK_SLEEP_ENABLE
#define __HAL_RCC_SDMMC1_CLK_SLEEP_DISABLE __HAL_RCC_SDIO_CLK_SLEEP_DISABLE
#define __HAL_RCC_SDMMC1_CLK_ENABLE __HAL_RCC_SDIO_CLK_ENABLE
#define __HAL_RCC_SDMMC1_CLK_DISABLE __HAL_RCC_SDIO_CLK_DISABLE
#define __HAL_RCC_SDMMC1_IS_CLK_ENABLED __HAL_RCC_SDIO_IS_CLK_ENABLED
#define __HAL_RCC_SDMMC1_IS_CLK_DISABLED __HAL_RCC_SDIO_IS_CLK_DISABLED
#define Sdmmc1ClockSelection SdioClockSelection
#define RCC_PERIPHCLK_SDMMC1 RCC_PERIPHCLK_SDIO
#define RCC_SDMMC1CLKSOURCE_CLK48 RCC_SDIOCLKSOURCE_CK48
#define RCC_SDMMC1CLKSOURCE_SYSCLK RCC_SDIOCLKSOURCE_SYSCLK
#define __HAL_RCC_SDMMC1_CONFIG __HAL_RCC_SDIO_CONFIG
#define __HAL_RCC_GET_SDMMC1_SOURCE __HAL_RCC_GET_SDIO_SOURCE
#endif
#if defined(STM32F7) || defined(STM32L4)
#define __HAL_RCC_SDIO_FORCE_RESET __HAL_RCC_SDMMC1_FORCE_RESET
#define __HAL_RCC_SDIO_RELEASE_RESET __HAL_RCC_SDMMC1_RELEASE_RESET
#define __HAL_RCC_SDIO_CLK_SLEEP_ENABLE __HAL_RCC_SDMMC1_CLK_SLEEP_ENABLE
#define __HAL_RCC_SDIO_CLK_SLEEP_DISABLE __HAL_RCC_SDMMC1_CLK_SLEEP_DISABLE
#define __HAL_RCC_SDIO_CLK_ENABLE __HAL_RCC_SDMMC1_CLK_ENABLE
#define __HAL_RCC_SDIO_CLK_DISABLE __HAL_RCC_SDMMC1_CLK_DISABLE
#define __HAL_RCC_SDIO_IS_CLK_ENABLED __HAL_RCC_SDMMC1_IS_CLK_ENABLED
#define __HAL_RCC_SDIO_IS_CLK_DISABLED __HAL_RCC_SDMMC1_IS_CLK_DISABLED
#define SdioClockSelection Sdmmc1ClockSelection
#define RCC_PERIPHCLK_SDIO RCC_PERIPHCLK_SDMMC1
#define __HAL_RCC_SDIO_CONFIG __HAL_RCC_SDMMC1_CONFIG
#define __HAL_RCC_GET_SDIO_SOURCE __HAL_RCC_GET_SDMMC1_SOURCE
#endif
#if defined(STM32F7)
#define RCC_SDIOCLKSOURCE_CLK48 RCC_SDMMC1CLKSOURCE_CLK48
#define RCC_SDIOCLKSOURCE_SYSCLK RCC_SDMMC1CLKSOURCE_SYSCLK
#endif
#define __HAL_RCC_I2SCLK __HAL_RCC_I2S_CONFIG
#define __HAL_RCC_I2SCLK_CONFIG __HAL_RCC_I2S_CONFIG
#define __RCC_PLLSRC RCC_GET_PLL_OSCSOURCE
#define IS_RCC_MSIRANGE IS_RCC_MSI_CLOCK_RANGE
#define IS_RCC_RTCCLK_SOURCE IS_RCC_RTCCLKSOURCE
#define IS_RCC_SYSCLK_DIV IS_RCC_HCLK
#define IS_RCC_HCLK_DIV IS_RCC_PCLK
#define IS_RCC_PERIPHCLK IS_RCC_PERIPHCLOCK
#define RCC_IT_HSI14 RCC_IT_HSI14RDY
#define RCC_IT_CSSLSE RCC_IT_LSECSS
#define RCC_IT_CSSHSE RCC_IT_CSS
#define RCC_PLLMUL_3 RCC_PLL_MUL3
#define RCC_PLLMUL_4 RCC_PLL_MUL4
#define RCC_PLLMUL_6 RCC_PLL_MUL6
#define RCC_PLLMUL_8 RCC_PLL_MUL8
#define RCC_PLLMUL_12 RCC_PLL_MUL12
#define RCC_PLLMUL_16 RCC_PLL_MUL16
#define RCC_PLLMUL_24 RCC_PLL_MUL24
#define RCC_PLLMUL_32 RCC_PLL_MUL32
#define RCC_PLLMUL_48 RCC_PLL_MUL48
#define RCC_PLLDIV_2 RCC_PLL_DIV2
#define RCC_PLLDIV_3 RCC_PLL_DIV3
#define RCC_PLLDIV_4 RCC_PLL_DIV4
#define IS_RCC_MCOSOURCE IS_RCC_MCO1SOURCE
#define __HAL_RCC_MCO_CONFIG __HAL_RCC_MCO1_CONFIG
#define RCC_MCO_NODIV RCC_MCODIV_1
#define RCC_MCO_DIV1 RCC_MCODIV_1
#define RCC_MCO_DIV2 RCC_MCODIV_2
#define RCC_MCO_DIV4 RCC_MCODIV_4
#define RCC_MCO_DIV8 RCC_MCODIV_8
#define RCC_MCO_DIV16 RCC_MCODIV_16
#define RCC_MCO_DIV32 RCC_MCODIV_32
#define RCC_MCO_DIV64 RCC_MCODIV_64
#define RCC_MCO_DIV128 RCC_MCODIV_128
#define RCC_MCOSOURCE_NONE RCC_MCO1SOURCE_NOCLOCK
#define RCC_MCOSOURCE_LSI RCC_MCO1SOURCE_LSI
#define RCC_MCOSOURCE_LSE RCC_MCO1SOURCE_LSE
#define RCC_MCOSOURCE_SYSCLK RCC_MCO1SOURCE_SYSCLK
#define RCC_MCOSOURCE_HSI RCC_MCO1SOURCE_HSI
#define RCC_MCOSOURCE_HSI14 RCC_MCO1SOURCE_HSI14
#define RCC_MCOSOURCE_HSI48 RCC_MCO1SOURCE_HSI48
#define RCC_MCOSOURCE_HSE RCC_MCO1SOURCE_HSE
#define RCC_MCOSOURCE_PLLCLK_DIV1 RCC_MCO1SOURCE_PLLCLK
#define RCC_MCOSOURCE_PLLCLK_NODIV RCC_MCO1SOURCE_PLLCLK
#define RCC_MCOSOURCE_PLLCLK_DIV2 RCC_MCO1SOURCE_PLLCLK_DIV2
#if defined(STM32WB) || defined(STM32G0)
#else
#define RCC_RTCCLKSOURCE_NONE RCC_RTCCLKSOURCE_NO_CLK
#endif
#define RCC_USBCLK_PLLSAI1 RCC_USBCLKSOURCE_PLLSAI1
#define RCC_USBCLK_PLL RCC_USBCLKSOURCE_PLL
#define RCC_USBCLK_MSI RCC_USBCLKSOURCE_MSI
#define RCC_USBCLKSOURCE_PLLCLK RCC_USBCLKSOURCE_PLL
#define RCC_USBPLLCLK_DIV1 RCC_USBCLKSOURCE_PLL
#define RCC_USBPLLCLK_DIV1_5 RCC_USBCLKSOURCE_PLL_DIV1_5
#define RCC_USBPLLCLK_DIV2 RCC_USBCLKSOURCE_PLL_DIV2
#define RCC_USBPLLCLK_DIV3 RCC_USBCLKSOURCE_PLL_DIV3
#define HSION_BitNumber RCC_HSION_BIT_NUMBER
#define HSION_BITNUMBER RCC_HSION_BIT_NUMBER
#define HSEON_BitNumber RCC_HSEON_BIT_NUMBER
#define HSEON_BITNUMBER RCC_HSEON_BIT_NUMBER
#define MSION_BITNUMBER RCC_MSION_BIT_NUMBER
#define CSSON_BitNumber RCC_CSSON_BIT_NUMBER
#define CSSON_BITNUMBER RCC_CSSON_BIT_NUMBER
#define PLLON_BitNumber RCC_PLLON_BIT_NUMBER
#define PLLON_BITNUMBER RCC_PLLON_BIT_NUMBER
#define PLLI2SON_BitNumber RCC_PLLI2SON_BIT_NUMBER
#define I2SSRC_BitNumber RCC_I2SSRC_BIT_NUMBER
#define RTCEN_BitNumber RCC_RTCEN_BIT_NUMBER
#define RTCEN_BITNUMBER RCC_RTCEN_BIT_NUMBER
#define BDRST_BitNumber RCC_BDRST_BIT_NUMBER
#define BDRST_BITNUMBER RCC_BDRST_BIT_NUMBER
#define RTCRST_BITNUMBER RCC_RTCRST_BIT_NUMBER
#define LSION_BitNumber RCC_LSION_BIT_NUMBER
#define LSION_BITNUMBER RCC_LSION_BIT_NUMBER
#define LSEON_BitNumber RCC_LSEON_BIT_NUMBER
#define LSEON_BITNUMBER RCC_LSEON_BIT_NUMBER
#define LSEBYP_BITNUMBER RCC_LSEBYP_BIT_NUMBER
#define PLLSAION_BitNumber RCC_PLLSAION_BIT_NUMBER
#define TIMPRE_BitNumber RCC_TIMPRE_BIT_NUMBER
#define RMVF_BitNumber RCC_RMVF_BIT_NUMBER
#define RMVF_BITNUMBER RCC_RMVF_BIT_NUMBER
#define RCC_CR2_HSI14TRIM_BitNumber RCC_HSI14TRIM_BIT_NUMBER
#define CR_BYTE2_ADDRESS RCC_CR_BYTE2_ADDRESS
#define CIR_BYTE1_ADDRESS RCC_CIR_BYTE1_ADDRESS
#define CIR_BYTE2_ADDRESS RCC_CIR_BYTE2_ADDRESS
#define BDCR_BYTE0_ADDRESS RCC_BDCR_BYTE0_ADDRESS
#define DBP_TIMEOUT_VALUE RCC_DBP_TIMEOUT_VALUE
#define LSE_TIMEOUT_VALUE RCC_LSE_TIMEOUT_VALUE
#define CR_HSION_BB RCC_CR_HSION_BB
#define CR_CSSON_BB RCC_CR_CSSON_BB
#define CR_PLLON_BB RCC_CR_PLLON_BB
#define CR_PLLI2SON_BB RCC_CR_PLLI2SON_BB
#define CR_MSION_BB RCC_CR_MSION_BB
#define CSR_LSION_BB RCC_CSR_LSION_BB
#define CSR_LSEON_BB RCC_CSR_LSEON_BB
#define CSR_LSEBYP_BB RCC_CSR_LSEBYP_BB
#define CSR_RTCEN_BB RCC_CSR_RTCEN_BB
#define CSR_RTCRST_BB RCC_CSR_RTCRST_BB
#define CFGR_I2SSRC_BB RCC_CFGR_I2SSRC_BB
#define BDCR_RTCEN_BB RCC_BDCR_RTCEN_BB
#define BDCR_BDRST_BB RCC_BDCR_BDRST_BB
#define CR_HSEON_BB RCC_CR_HSEON_BB
#define CSR_RMVF_BB RCC_CSR_RMVF_BB
#define CR_PLLSAION_BB RCC_CR_PLLSAION_BB
#define DCKCFGR_TIMPRE_BB RCC_DCKCFGR_TIMPRE_BB
#define __HAL_RCC_CRS_ENABLE_FREQ_ERROR_COUNTER __HAL_RCC_CRS_FREQ_ERROR_COUNTER_ENABLE
#define __HAL_RCC_CRS_DISABLE_FREQ_ERROR_COUNTER __HAL_RCC_CRS_FREQ_ERROR_COUNTER_DISABLE
#define __HAL_RCC_CRS_ENABLE_AUTOMATIC_CALIB __HAL_RCC_CRS_AUTOMATIC_CALIB_ENABLE
#define __HAL_RCC_CRS_DISABLE_AUTOMATIC_CALIB __HAL_RCC_CRS_AUTOMATIC_CALIB_DISABLE
#define __HAL_RCC_CRS_CALCULATE_RELOADVALUE __HAL_RCC_CRS_RELOADVALUE_CALCULATE
#define __HAL_RCC_GET_IT_SOURCE __HAL_RCC_GET_IT
#define RCC_CRS_SYNCWARM RCC_CRS_SYNCWARN
#define RCC_CRS_TRIMOV RCC_CRS_TRIMOVF
#define RCC_PERIPHCLK_CK48 RCC_PERIPHCLK_CLK48
#define RCC_CK48CLKSOURCE_PLLQ RCC_CLK48CLKSOURCE_PLLQ
#define RCC_CK48CLKSOURCE_PLLSAIP RCC_CLK48CLKSOURCE_PLLSAIP
#define RCC_CK48CLKSOURCE_PLLI2SQ RCC_CLK48CLKSOURCE_PLLI2SQ
#define IS_RCC_CK48CLKSOURCE IS_RCC_CLK48CLKSOURCE
#define RCC_SDIOCLKSOURCE_CK48 RCC_SDIOCLKSOURCE_CLK48
#define __HAL_RCC_DFSDM_CLK_ENABLE __HAL_RCC_DFSDM1_CLK_ENABLE
#define __HAL_RCC_DFSDM_CLK_DISABLE __HAL_RCC_DFSDM1_CLK_DISABLE
#define __HAL_RCC_DFSDM_IS_CLK_ENABLED __HAL_RCC_DFSDM1_IS_CLK_ENABLED
#define __HAL_RCC_DFSDM_IS_CLK_DISABLED __HAL_RCC_DFSDM1_IS_CLK_DISABLED
#define __HAL_RCC_DFSDM_FORCE_RESET __HAL_RCC_DFSDM1_FORCE_RESET
#define __HAL_RCC_DFSDM_RELEASE_RESET __HAL_RCC_DFSDM1_RELEASE_RESET
#define __HAL_RCC_DFSDM_CLK_SLEEP_ENABLE __HAL_RCC_DFSDM1_CLK_SLEEP_ENABLE
#define __HAL_RCC_DFSDM_CLK_SLEEP_DISABLE __HAL_RCC_DFSDM1_CLK_SLEEP_DISABLE
#define __HAL_RCC_DFSDM_IS_CLK_SLEEP_ENABLED __HAL_RCC_DFSDM1_IS_CLK_SLEEP_ENABLED
#define __HAL_RCC_DFSDM_IS_CLK_SLEEP_DISABLED __HAL_RCC_DFSDM1_IS_CLK_SLEEP_DISABLED
#define DfsdmClockSelection Dfsdm1ClockSelection
#define RCC_PERIPHCLK_DFSDM RCC_PERIPHCLK_DFSDM1
#define RCC_DFSDMCLKSOURCE_PCLK RCC_DFSDM1CLKSOURCE_PCLK
#define RCC_DFSDMCLKSOURCE_SYSCLK RCC_DFSDM1CLKSOURCE_SYSCLK
#define __HAL_RCC_DFSDM_CONFIG __HAL_RCC_DFSDM1_CONFIG
#define __HAL_RCC_GET_DFSDM_SOURCE __HAL_RCC_GET_DFSDM1_SOURCE
/**
* @}
*/
/** @defgroup HAL_RNG_Aliased_Macros HAL RNG Aliased Macros maintained for legacy purpose
* @{
*/
#define HAL_RNG_ReadyCallback(__HANDLE__) HAL_RNG_ReadyDataCallback((__HANDLE__), uint32_t random32bit)
/**
* @}
*/
/** @defgroup HAL_RTC_Aliased_Macros HAL RTC Aliased Macros maintained for legacy purpose
* @{
*/
#if defined (STM32G0)
#else
#define __HAL_RTC_CLEAR_FLAG __HAL_RTC_EXTI_CLEAR_FLAG
#endif
#define __HAL_RTC_DISABLE_IT __HAL_RTC_EXTI_DISABLE_IT
#define __HAL_RTC_ENABLE_IT __HAL_RTC_EXTI_ENABLE_IT
#if defined (STM32F1)
#define __HAL_RTC_EXTI_CLEAR_FLAG(RTC_EXTI_LINE_ALARM_EVENT) __HAL_RTC_ALARM_EXTI_CLEAR_FLAG()
#define __HAL_RTC_EXTI_ENABLE_IT(RTC_EXTI_LINE_ALARM_EVENT) __HAL_RTC_ALARM_EXTI_ENABLE_IT()
#define __HAL_RTC_EXTI_DISABLE_IT(RTC_EXTI_LINE_ALARM_EVENT) __HAL_RTC_ALARM_EXTI_DISABLE_IT()
#define __HAL_RTC_EXTI_GET_FLAG(RTC_EXTI_LINE_ALARM_EVENT) __HAL_RTC_ALARM_EXTI_GET_FLAG()
#define __HAL_RTC_EXTI_GENERATE_SWIT(RTC_EXTI_LINE_ALARM_EVENT) __HAL_RTC_ALARM_EXTI_GENERATE_SWIT()
#else
#define __HAL_RTC_EXTI_CLEAR_FLAG(__EXTI_LINE__) (((__EXTI_LINE__) == RTC_EXTI_LINE_ALARM_EVENT) ? __HAL_RTC_ALARM_EXTI_CLEAR_FLAG() : \
(((__EXTI_LINE__) == RTC_EXTI_LINE_WAKEUPTIMER_EVENT) ? __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG() : \
__HAL_RTC_TAMPER_TIMESTAMP_EXTI_CLEAR_FLAG()))
#define __HAL_RTC_EXTI_ENABLE_IT(__EXTI_LINE__) (((__EXTI_LINE__) == RTC_EXTI_LINE_ALARM_EVENT) ? __HAL_RTC_ALARM_EXTI_ENABLE_IT() : \
(((__EXTI_LINE__) == RTC_EXTI_LINE_WAKEUPTIMER_EVENT) ? __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT() : \
__HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT()))
#define __HAL_RTC_EXTI_DISABLE_IT(__EXTI_LINE__) (((__EXTI_LINE__) == RTC_EXTI_LINE_ALARM_EVENT) ? __HAL_RTC_ALARM_EXTI_DISABLE_IT() : \
(((__EXTI_LINE__) == RTC_EXTI_LINE_WAKEUPTIMER_EVENT) ? __HAL_RTC_WAKEUPTIMER_EXTI_DISABLE_IT() : \
__HAL_RTC_TAMPER_TIMESTAMP_EXTI_DISABLE_IT()))
#define __HAL_RTC_EXTI_GET_FLAG(__EXTI_LINE__) (((__EXTI_LINE__) == RTC_EXTI_LINE_ALARM_EVENT) ? __HAL_RTC_ALARM_EXTI_GET_FLAG() : \
(((__EXTI_LINE__) == RTC_EXTI_LINE_WAKEUPTIMER_EVENT) ? __HAL_RTC_WAKEUPTIMER_EXTI_GET_FLAG() : \
__HAL_RTC_TAMPER_TIMESTAMP_EXTI_GET_FLAG()))
#define __HAL_RTC_EXTI_GENERATE_SWIT(__EXTI_LINE__) (((__EXTI_LINE__) == RTC_EXTI_LINE_ALARM_EVENT) ? __HAL_RTC_ALARM_EXTI_GENERATE_SWIT() : \
(((__EXTI_LINE__) == RTC_EXTI_LINE_WAKEUPTIMER_EVENT) ? __HAL_RTC_WAKEUPTIMER_EXTI_GENERATE_SWIT() : \
__HAL_RTC_TAMPER_TIMESTAMP_EXTI_GENERATE_SWIT()))
#endif /* STM32F1 */
#define IS_ALARM IS_RTC_ALARM
#define IS_ALARM_MASK IS_RTC_ALARM_MASK
#define IS_TAMPER IS_RTC_TAMPER
#define IS_TAMPER_ERASE_MODE IS_RTC_TAMPER_ERASE_MODE
#define IS_TAMPER_FILTER IS_RTC_TAMPER_FILTER
#define IS_TAMPER_INTERRUPT IS_RTC_TAMPER_INTERRUPT
#define IS_TAMPER_MASKFLAG_STATE IS_RTC_TAMPER_MASKFLAG_STATE
#define IS_TAMPER_PRECHARGE_DURATION IS_RTC_TAMPER_PRECHARGE_DURATION
#define IS_TAMPER_PULLUP_STATE IS_RTC_TAMPER_PULLUP_STATE
#define IS_TAMPER_SAMPLING_FREQ IS_RTC_TAMPER_SAMPLING_FREQ
#define IS_TAMPER_TIMESTAMPONTAMPER_DETECTION IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION
#define IS_TAMPER_TRIGGER IS_RTC_TAMPER_TRIGGER
#define IS_WAKEUP_CLOCK IS_RTC_WAKEUP_CLOCK
#define IS_WAKEUP_COUNTER IS_RTC_WAKEUP_COUNTER
#define __RTC_WRITEPROTECTION_ENABLE __HAL_RTC_WRITEPROTECTION_ENABLE
#define __RTC_WRITEPROTECTION_DISABLE __HAL_RTC_WRITEPROTECTION_DISABLE
/**
* @}
*/
/** @defgroup HAL_SD_Aliased_Macros HAL SD Aliased Macros maintained for legacy purpose
* @{
*/
#define SD_OCR_CID_CSD_OVERWRIETE SD_OCR_CID_CSD_OVERWRITE
#define SD_CMD_SD_APP_STAUS SD_CMD_SD_APP_STATUS
#if defined(STM32F4)
#define SD_SDMMC_DISABLED SD_SDIO_DISABLED
#define SD_SDMMC_FUNCTION_BUSY SD_SDIO_FUNCTION_BUSY
#define SD_SDMMC_FUNCTION_FAILED SD_SDIO_FUNCTION_FAILED
#define SD_SDMMC_UNKNOWN_FUNCTION SD_SDIO_UNKNOWN_FUNCTION
#define SD_CMD_SDMMC_SEN_OP_COND SD_CMD_SDIO_SEN_OP_COND
#define SD_CMD_SDMMC_RW_DIRECT SD_CMD_SDIO_RW_DIRECT
#define SD_CMD_SDMMC_RW_EXTENDED SD_CMD_SDIO_RW_EXTENDED
#define __HAL_SD_SDMMC_ENABLE __HAL_SD_SDIO_ENABLE
#define __HAL_SD_SDMMC_DISABLE __HAL_SD_SDIO_DISABLE
#define __HAL_SD_SDMMC_DMA_ENABLE __HAL_SD_SDIO_DMA_ENABLE
#define __HAL_SD_SDMMC_DMA_DISABLE __HAL_SD_SDIO_DMA_DISABL
#define __HAL_SD_SDMMC_ENABLE_IT __HAL_SD_SDIO_ENABLE_IT
#define __HAL_SD_SDMMC_DISABLE_IT __HAL_SD_SDIO_DISABLE_IT
#define __HAL_SD_SDMMC_GET_FLAG __HAL_SD_SDIO_GET_FLAG
#define __HAL_SD_SDMMC_CLEAR_FLAG __HAL_SD_SDIO_CLEAR_FLAG
#define __HAL_SD_SDMMC_GET_IT __HAL_SD_SDIO_GET_IT
#define __HAL_SD_SDMMC_CLEAR_IT __HAL_SD_SDIO_CLEAR_IT
#define SDMMC_STATIC_FLAGS SDIO_STATIC_FLAGS
#define SDMMC_CMD0TIMEOUT SDIO_CMD0TIMEOUT
#define SD_SDMMC_SEND_IF_COND SD_SDIO_SEND_IF_COND
/* alias CMSIS */
#define SDMMC1_IRQn SDIO_IRQn
#define SDMMC1_IRQHandler SDIO_IRQHandler
#endif
#if defined(STM32F7) || defined(STM32L4)
#define SD_SDIO_DISABLED SD_SDMMC_DISABLED
#define SD_SDIO_FUNCTION_BUSY SD_SDMMC_FUNCTION_BUSY
#define SD_SDIO_FUNCTION_FAILED SD_SDMMC_FUNCTION_FAILED
#define SD_SDIO_UNKNOWN_FUNCTION SD_SDMMC_UNKNOWN_FUNCTION
#define SD_CMD_SDIO_SEN_OP_COND SD_CMD_SDMMC_SEN_OP_COND
#define SD_CMD_SDIO_RW_DIRECT SD_CMD_SDMMC_RW_DIRECT
#define SD_CMD_SDIO_RW_EXTENDED SD_CMD_SDMMC_RW_EXTENDED
#define __HAL_SD_SDIO_ENABLE __HAL_SD_SDMMC_ENABLE
#define __HAL_SD_SDIO_DISABLE __HAL_SD_SDMMC_DISABLE
#define __HAL_SD_SDIO_DMA_ENABLE __HAL_SD_SDMMC_DMA_ENABLE
#define __HAL_SD_SDIO_DMA_DISABL __HAL_SD_SDMMC_DMA_DISABLE
#define __HAL_SD_SDIO_ENABLE_IT __HAL_SD_SDMMC_ENABLE_IT
#define __HAL_SD_SDIO_DISABLE_IT __HAL_SD_SDMMC_DISABLE_IT
#define __HAL_SD_SDIO_GET_FLAG __HAL_SD_SDMMC_GET_FLAG
#define __HAL_SD_SDIO_CLEAR_FLAG __HAL_SD_SDMMC_CLEAR_FLAG
#define __HAL_SD_SDIO_GET_IT __HAL_SD_SDMMC_GET_IT
#define __HAL_SD_SDIO_CLEAR_IT __HAL_SD_SDMMC_CLEAR_IT
#define SDIO_STATIC_FLAGS SDMMC_STATIC_FLAGS
#define SDIO_CMD0TIMEOUT SDMMC_CMD0TIMEOUT
#define SD_SDIO_SEND_IF_COND SD_SDMMC_SEND_IF_COND
/* alias CMSIS for compatibilities */
#define SDIO_IRQn SDMMC1_IRQn
#define SDIO_IRQHandler SDMMC1_IRQHandler
#endif
/**
* @}
*/
/** @defgroup HAL_SMARTCARD_Aliased_Macros HAL SMARTCARD Aliased Macros maintained for legacy purpose
* @{
*/
#define __SMARTCARD_ENABLE_IT __HAL_SMARTCARD_ENABLE_IT
#define __SMARTCARD_DISABLE_IT __HAL_SMARTCARD_DISABLE_IT
#define __SMARTCARD_ENABLE __HAL_SMARTCARD_ENABLE
#define __SMARTCARD_DISABLE __HAL_SMARTCARD_DISABLE
#define __SMARTCARD_DMA_REQUEST_ENABLE __HAL_SMARTCARD_DMA_REQUEST_ENABLE
#define __SMARTCARD_DMA_REQUEST_DISABLE __HAL_SMARTCARD_DMA_REQUEST_DISABLE
#define __HAL_SMARTCARD_GETCLOCKSOURCE SMARTCARD_GETCLOCKSOURCE
#define __SMARTCARD_GETCLOCKSOURCE SMARTCARD_GETCLOCKSOURCE
#define IS_SMARTCARD_ONEBIT_SAMPLING IS_SMARTCARD_ONE_BIT_SAMPLE
/**
* @}
*/
/** @defgroup HAL_SMBUS_Aliased_Macros HAL SMBUS Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_SMBUS_RESET_CR1 SMBUS_RESET_CR1
#define __HAL_SMBUS_RESET_CR2 SMBUS_RESET_CR2
#define __HAL_SMBUS_GENERATE_START SMBUS_GENERATE_START
#define __HAL_SMBUS_GET_ADDR_MATCH SMBUS_GET_ADDR_MATCH
#define __HAL_SMBUS_GET_DIR SMBUS_GET_DIR
#define __HAL_SMBUS_GET_STOP_MODE SMBUS_GET_STOP_MODE
#define __HAL_SMBUS_GET_PEC_MODE SMBUS_GET_PEC_MODE
#define __HAL_SMBUS_GET_ALERT_ENABLED SMBUS_GET_ALERT_ENABLED
/**
* @}
*/
/** @defgroup HAL_SPI_Aliased_Macros HAL SPI Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_SPI_1LINE_TX SPI_1LINE_TX
#define __HAL_SPI_1LINE_RX SPI_1LINE_RX
#define __HAL_SPI_RESET_CRC SPI_RESET_CRC
/**
* @}
*/
/** @defgroup HAL_UART_Aliased_Macros HAL UART Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_UART_GETCLOCKSOURCE UART_GETCLOCKSOURCE
#define __HAL_UART_MASK_COMPUTATION UART_MASK_COMPUTATION
#define __UART_GETCLOCKSOURCE UART_GETCLOCKSOURCE
#define __UART_MASK_COMPUTATION UART_MASK_COMPUTATION
#define IS_UART_WAKEUPMETHODE IS_UART_WAKEUPMETHOD
#define IS_UART_ONEBIT_SAMPLE IS_UART_ONE_BIT_SAMPLE
#define IS_UART_ONEBIT_SAMPLING IS_UART_ONE_BIT_SAMPLE
/**
* @}
*/
/** @defgroup HAL_USART_Aliased_Macros HAL USART Aliased Macros maintained for legacy purpose
* @{
*/
#define __USART_ENABLE_IT __HAL_USART_ENABLE_IT
#define __USART_DISABLE_IT __HAL_USART_DISABLE_IT
#define __USART_ENABLE __HAL_USART_ENABLE
#define __USART_DISABLE __HAL_USART_DISABLE
#define __HAL_USART_GETCLOCKSOURCE USART_GETCLOCKSOURCE
#define __USART_GETCLOCKSOURCE USART_GETCLOCKSOURCE
/**
* @}
*/
/** @defgroup HAL_USB_Aliased_Macros HAL USB Aliased Macros maintained for legacy purpose
* @{
*/
#define USB_EXTI_LINE_WAKEUP USB_WAKEUP_EXTI_LINE
#define USB_FS_EXTI_TRIGGER_RISING_EDGE USB_OTG_FS_WAKEUP_EXTI_RISING_EDGE
#define USB_FS_EXTI_TRIGGER_FALLING_EDGE USB_OTG_FS_WAKEUP_EXTI_FALLING_EDGE
#define USB_FS_EXTI_TRIGGER_BOTH_EDGE USB_OTG_FS_WAKEUP_EXTI_RISING_FALLING_EDGE
#define USB_FS_EXTI_LINE_WAKEUP USB_OTG_FS_WAKEUP_EXTI_LINE
#define USB_HS_EXTI_TRIGGER_RISING_EDGE USB_OTG_HS_WAKEUP_EXTI_RISING_EDGE
#define USB_HS_EXTI_TRIGGER_FALLING_EDGE USB_OTG_HS_WAKEUP_EXTI_FALLING_EDGE
#define USB_HS_EXTI_TRIGGER_BOTH_EDGE USB_OTG_HS_WAKEUP_EXTI_RISING_FALLING_EDGE
#define USB_HS_EXTI_LINE_WAKEUP USB_OTG_HS_WAKEUP_EXTI_LINE
#define __HAL_USB_EXTI_ENABLE_IT __HAL_USB_WAKEUP_EXTI_ENABLE_IT
#define __HAL_USB_EXTI_DISABLE_IT __HAL_USB_WAKEUP_EXTI_DISABLE_IT
#define __HAL_USB_EXTI_GET_FLAG __HAL_USB_WAKEUP_EXTI_GET_FLAG
#define __HAL_USB_EXTI_CLEAR_FLAG __HAL_USB_WAKEUP_EXTI_CLEAR_FLAG
#define __HAL_USB_EXTI_SET_RISING_EDGE_TRIGGER __HAL_USB_WAKEUP_EXTI_ENABLE_RISING_EDGE
#define __HAL_USB_EXTI_SET_FALLING_EDGE_TRIGGER __HAL_USB_WAKEUP_EXTI_ENABLE_FALLING_EDGE
#define __HAL_USB_EXTI_SET_FALLINGRISING_TRIGGER __HAL_USB_WAKEUP_EXTI_ENABLE_RISING_FALLING_EDGE
#define __HAL_USB_FS_EXTI_ENABLE_IT __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_IT
#define __HAL_USB_FS_EXTI_DISABLE_IT __HAL_USB_OTG_FS_WAKEUP_EXTI_DISABLE_IT
#define __HAL_USB_FS_EXTI_GET_FLAG __HAL_USB_OTG_FS_WAKEUP_EXTI_GET_FLAG
#define __HAL_USB_FS_EXTI_CLEAR_FLAG __HAL_USB_OTG_FS_WAKEUP_EXTI_CLEAR_FLAG
#define __HAL_USB_FS_EXTI_SET_RISING_EGDE_TRIGGER __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_RISING_EDGE
#define __HAL_USB_FS_EXTI_SET_FALLING_EGDE_TRIGGER __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_FALLING_EDGE
#define __HAL_USB_FS_EXTI_SET_FALLINGRISING_TRIGGER __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_RISING_FALLING_EDGE
#define __HAL_USB_FS_EXTI_GENERATE_SWIT __HAL_USB_OTG_FS_WAKEUP_EXTI_GENERATE_SWIT
#define __HAL_USB_HS_EXTI_ENABLE_IT __HAL_USB_OTG_HS_WAKEUP_EXTI_ENABLE_IT
#define __HAL_USB_HS_EXTI_DISABLE_IT __HAL_USB_OTG_HS_WAKEUP_EXTI_DISABLE_IT
#define __HAL_USB_HS_EXTI_GET_FLAG __HAL_USB_OTG_HS_WAKEUP_EXTI_GET_FLAG
#define __HAL_USB_HS_EXTI_CLEAR_FLAG __HAL_USB_OTG_HS_WAKEUP_EXTI_CLEAR_FLAG
#define __HAL_USB_HS_EXTI_SET_RISING_EGDE_TRIGGER __HAL_USB_OTG_HS_WAKEUP_EXTI_ENABLE_RISING_EDGE
#define __HAL_USB_HS_EXTI_SET_FALLING_EGDE_TRIGGER __HAL_USB_OTG_HS_WAKEUP_EXTI_ENABLE_FALLING_EDGE
#define __HAL_USB_HS_EXTI_SET_FALLINGRISING_TRIGGER __HAL_USB_OTG_HS_WAKEUP_EXTI_ENABLE_RISING_FALLING_EDGE
#define __HAL_USB_HS_EXTI_GENERATE_SWIT __HAL_USB_OTG_HS_WAKEUP_EXTI_GENERATE_SWIT
#define HAL_PCD_ActiveRemoteWakeup HAL_PCD_ActivateRemoteWakeup
#define HAL_PCD_DeActiveRemoteWakeup HAL_PCD_DeActivateRemoteWakeup
#define HAL_PCD_SetTxFiFo HAL_PCDEx_SetTxFiFo
#define HAL_PCD_SetRxFiFo HAL_PCDEx_SetRxFiFo
/**
* @}
*/
/** @defgroup HAL_TIM_Aliased_Macros HAL TIM Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_TIM_SetICPrescalerValue TIM_SET_ICPRESCALERVALUE
#define __HAL_TIM_ResetICPrescalerValue TIM_RESET_ICPRESCALERVALUE
#define TIM_GET_ITSTATUS __HAL_TIM_GET_IT_SOURCE
#define TIM_GET_CLEAR_IT __HAL_TIM_CLEAR_IT
#define __HAL_TIM_GET_ITSTATUS __HAL_TIM_GET_IT_SOURCE
#define __HAL_TIM_DIRECTION_STATUS __HAL_TIM_IS_TIM_COUNTING_DOWN
#define __HAL_TIM_PRESCALER __HAL_TIM_SET_PRESCALER
#define __HAL_TIM_SetCounter __HAL_TIM_SET_COUNTER
#define __HAL_TIM_GetCounter __HAL_TIM_GET_COUNTER
#define __HAL_TIM_SetAutoreload __HAL_TIM_SET_AUTORELOAD
#define __HAL_TIM_GetAutoreload __HAL_TIM_GET_AUTORELOAD
#define __HAL_TIM_SetClockDivision __HAL_TIM_SET_CLOCKDIVISION
#define __HAL_TIM_GetClockDivision __HAL_TIM_GET_CLOCKDIVISION
#define __HAL_TIM_SetICPrescaler __HAL_TIM_SET_ICPRESCALER
#define __HAL_TIM_GetICPrescaler __HAL_TIM_GET_ICPRESCALER
#define __HAL_TIM_SetCompare __HAL_TIM_SET_COMPARE
#define __HAL_TIM_GetCompare __HAL_TIM_GET_COMPARE
#define TIM_BREAKINPUTSOURCE_DFSDM TIM_BREAKINPUTSOURCE_DFSDM1
/**
* @}
*/
/** @defgroup HAL_ETH_Aliased_Macros HAL ETH Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_ETH_EXTI_ENABLE_IT __HAL_ETH_WAKEUP_EXTI_ENABLE_IT
#define __HAL_ETH_EXTI_DISABLE_IT __HAL_ETH_WAKEUP_EXTI_DISABLE_IT
#define __HAL_ETH_EXTI_GET_FLAG __HAL_ETH_WAKEUP_EXTI_GET_FLAG
#define __HAL_ETH_EXTI_CLEAR_FLAG __HAL_ETH_WAKEUP_EXTI_CLEAR_FLAG
#define __HAL_ETH_EXTI_SET_RISING_EGDE_TRIGGER __HAL_ETH_WAKEUP_EXTI_ENABLE_RISING_EDGE_TRIGGER
#define __HAL_ETH_EXTI_SET_FALLING_EGDE_TRIGGER __HAL_ETH_WAKEUP_EXTI_ENABLE_FALLING_EDGE_TRIGGER
#define __HAL_ETH_EXTI_SET_FALLINGRISING_TRIGGER __HAL_ETH_WAKEUP_EXTI_ENABLE_FALLINGRISING_TRIGGER
#define ETH_PROMISCIOUSMODE_ENABLE ETH_PROMISCUOUS_MODE_ENABLE
#define ETH_PROMISCIOUSMODE_DISABLE ETH_PROMISCUOUS_MODE_DISABLE
#define IS_ETH_PROMISCIOUS_MODE IS_ETH_PROMISCUOUS_MODE
/**
* @}
*/
/** @defgroup HAL_LTDC_Aliased_Macros HAL LTDC Aliased Macros maintained for legacy purpose
* @{
*/
#define __HAL_LTDC_LAYER LTDC_LAYER
/**
* @}
*/
/** @defgroup HAL_SAI_Aliased_Macros HAL SAI Aliased Macros maintained for legacy purpose
* @{
*/
#define SAI_OUTPUTDRIVE_DISABLED SAI_OUTPUTDRIVE_DISABLE
#define SAI_OUTPUTDRIVE_ENABLED SAI_OUTPUTDRIVE_ENABLE
#define SAI_MASTERDIVIDER_ENABLED SAI_MASTERDIVIDER_ENABLE
#define SAI_MASTERDIVIDER_DISABLED SAI_MASTERDIVIDER_DISABLE
#define SAI_STREOMODE SAI_STEREOMODE
#define SAI_FIFOStatus_Empty SAI_FIFOSTATUS_EMPTY
#define SAI_FIFOStatus_Less1QuarterFull SAI_FIFOSTATUS_LESS1QUARTERFULL
#define SAI_FIFOStatus_1QuarterFull SAI_FIFOSTATUS_1QUARTERFULL
#define SAI_FIFOStatus_HalfFull SAI_FIFOSTATUS_HALFFULL
#define SAI_FIFOStatus_3QuartersFull SAI_FIFOSTATUS_3QUARTERFULL
#define SAI_FIFOStatus_Full SAI_FIFOSTATUS_FULL
#define IS_SAI_BLOCK_MONO_STREO_MODE IS_SAI_BLOCK_MONO_STEREO_MODE
#define SAI_SYNCHRONOUS_EXT SAI_SYNCHRONOUS_EXT_SAI1
#define SAI_SYNCEXT_IN_ENABLE SAI_SYNCEXT_OUTBLOCKA_ENABLE
/**
* @}
*/
/** @defgroup HAL_PPP_Aliased_Macros HAL PPP Aliased Macros maintained for legacy purpose
* @{
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* ___STM32_HAL_LEGACY */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
| {'content_hash': 'e2cf38a20efc64a259ee614b35523c11', 'timestamp': '', 'source': 'github', 'line_count': 3181, 'max_line_length': 189, 'avg_line_length': 55.5014146494813, 'alnum_prop': 0.6491645426224866, 'repo_name': 'AubrCool/rt-thread', 'id': '77647df28f19395359eced096e0cd88040347d2b', 'size': '178654', 'binary': False, 'copies': '28', 'ref': 'refs/heads/master', 'path': 'bsp/stm32/libraries/STM32L0xx_HAL/STM32L0xx_HAL_Driver/Inc/Legacy/stm32_hal_legacy.h', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Assembly', 'bytes': '12839996'}, {'name': 'Batchfile', 'bytes': '186191'}, {'name': 'C', 'bytes': '615578916'}, {'name': 'C++', 'bytes': '7535608'}, {'name': 'CMake', 'bytes': '148026'}, {'name': 'CSS', 'bytes': '9978'}, {'name': 'DIGITAL Command Language', 'bytes': '13234'}, {'name': 'GDB', 'bytes': '11796'}, {'name': 'HTML', 'bytes': '5455013'}, {'name': 'Lex', 'bytes': '7026'}, {'name': 'Logos', 'bytes': '7078'}, {'name': 'M4', 'bytes': '17515'}, {'name': 'Makefile', 'bytes': '271627'}, {'name': 'Module Management System', 'bytes': '1548'}, {'name': 'Objective-C', 'bytes': '4110192'}, {'name': 'Pawn', 'bytes': '1427'}, {'name': 'Perl', 'bytes': '9520'}, {'name': 'Python', 'bytes': '1375160'}, {'name': 'RPC', 'bytes': '14162'}, {'name': 'Rich Text Format', 'bytes': '355402'}, {'name': 'Roff', 'bytes': '4486'}, {'name': 'Ruby', 'bytes': '869'}, {'name': 'Shell', 'bytes': '407723'}, {'name': 'TeX', 'bytes': '3113'}, {'name': 'Yacc', 'bytes': '16084'}]} |
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.18034
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Autumn.Mvc.Infrastructure.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Strings {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Strings() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Autumn.Mvc.Infrastructure.Resources.Strings", typeof(Strings).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to <RSAKeyValue><Modulus>lKdHGicZnSE+8QOrCRxd2v2wTE0Kjdu5ur7kziv5SFVDe30O41ysr9exxws1VszFxwQNwvJYWp5JV0kJhWpycxiAqMYhZFyYy1Jk0pWJvCly6vic6IZNzm7Vgo4izu9kN1RcS9CgoOUTmCe1hjJz82XqkT36EUDn8Ssi6AfDS80=</Modulus><Exponent>AQAB</Exponent><P>0C4fajhXEzO+gqkt7TJWbqJCIlP4CTMz5i/l4EKwz+7JmB0Mhbu5dUimSYylci6KEwp7XK9cH22+Cxzzn1cWTw==</P><Q>tsy67q0EAwSM2eDO7nA2k2Mw7L+a8NXzrt/M0avGSMqZJ4sJ49PXDodSFryZX44MN3/t6xORZaHy6Bsk66ARIw==</Q><DP>XS1XqD5BUvnk+ixovvK51tjPCvhUWyHMx+mGVSLkapzxJCFUWoMUVhdHPkIyRvHnoPAfGPPwIq0G04iIzje3Zw==< [rest of string was truncated]";.
/// </summary>
internal static string RSAPrivateKey {
get {
return ResourceManager.GetString("RSAPrivateKey", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to <RSAKeyValue><Modulus>lKdHGicZnSE+8QOrCRxd2v2wTE0Kjdu5ur7kziv5SFVDe30O41ysr9exxws1VszFxwQNwvJYWp5JV0kJhWpycxiAqMYhZFyYy1Jk0pWJvCly6vic6IZNzm7Vgo4izu9kN1RcS9CgoOUTmCe1hjJz82XqkT36EUDn8Ssi6AfDS80=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>.
/// </summary>
internal static string RSAPublicKey {
get {
return ResourceManager.GetString("RSAPublicKey", resourceCulture);
}
}
}
}
| {'content_hash': '293fb9b95230e124d394277790e20082', 'timestamp': '', 'source': 'github', 'line_count': 81, 'max_line_length': 667, 'avg_line_length': 52.55555555555556, 'alnum_prop': 0.6553911205073996, 'repo_name': 'brschwalm/Autumn', 'id': '8f81f2d123590a890ee0a56aa020479463126ddf', 'size': '4259', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'Infrastructure/Resources/Strings.Designer.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'ASP', 'bytes': '105'}, {'name': 'C#', 'bytes': '121864'}, {'name': 'JavaScript', 'bytes': '1640365'}, {'name': 'PowerShell', 'bytes': '69747'}, {'name': 'Puppet', 'bytes': '1877'}]} |
/** @file
*
* @defgroup memory_pool_internal Memory Pool Internal
* @{
* @ingroup memory_pool
*
* @brief Memory pool internal definitions
*/
#ifndef MEM_POOL_INTERNAL_H__
#define MEM_POOL_INTERNAL_H__
#define TX_BUF_SIZE 600u /**< TX buffer size in bytes. */
#define RX_BUF_SIZE TX_BUF_SIZE /**< RX buffer size in bytes. */
#define RX_BUF_QUEUE_SIZE 4u /**< RX buffer element size. */
#endif // MEM_POOL_INTERNAL_H__
/** @} */
| {'content_hash': '9378dd5a12ddda705444777593cec84f', 'timestamp': '', 'source': 'github', 'line_count': 23, 'max_line_length': 71, 'avg_line_length': 20.695652173913043, 'alnum_prop': 0.6008403361344538, 'repo_name': 'arostm/mbed-os', 'id': '92594915ac66ea81b9ea23f02a809a72058fc161', 'size': '2528', 'binary': False, 'copies': '79', 'ref': 'refs/heads/master', 'path': 'targets/TARGET_NORDIC/TARGET_NRF5/TARGET_SDK11/libraries/hci/config/hci_mem_pool_internal.h', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Assembly', 'bytes': '6349650'}, {'name': 'Batchfile', 'bytes': '22'}, {'name': 'C', 'bytes': '277785832'}, {'name': 'C++', 'bytes': '9306614'}, {'name': 'CMake', 'bytes': '5235'}, {'name': 'HTML', 'bytes': '2026143'}, {'name': 'Makefile', 'bytes': '103011'}, {'name': 'Objective-C', 'bytes': '432766'}, {'name': 'Perl', 'bytes': '2589'}, {'name': 'Python', 'bytes': '36524'}, {'name': 'Shell', 'bytes': '16819'}, {'name': 'XSLT', 'bytes': '5596'}]} |
cd ../vendor/dojo/util/buildscripts/
./build.sh --profile ../../../../builds/single-file.js | {'content_hash': '4103e352f717750ab6dcac1dd26402d7', 'timestamp': '', 'source': 'github', 'line_count': 2, 'max_line_length': 54, 'avg_line_length': 45.5, 'alnum_prop': 0.6593406593406593, 'repo_name': 'sirprize/dojorama', 'id': 'b822e9b7355e79daa0b5e2a6628c9f982057d898', 'size': '185', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'builds/single-file.sh', 'mode': '33261', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '140402'}, {'name': 'JavaScript', 'bytes': '8787868'}, {'name': 'PHP', 'bytes': '23352'}, {'name': 'Shell', 'bytes': '755'}]} |
package org.apache.struts.taglib.html;
import java.util.Locale;
import javax.servlet.jsp.PageContext;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.apache.cactus.JspTestCase;
import org.apache.struts.Globals;
/**
* Suite of unit tests for the
* <code>org.apache.struts.taglib.html.MessagesTag</code> class.
*
*/
public class TestMessagesTag2 extends JspTestCase {
/**
* Defines the testcase name for JUnit.
*
* @param theName the testcase's name.
*/
public TestMessagesTag2(String theName) {
super(theName);
}
/**
* Start the tests.
*
* @param theArgs the arguments. Not used
*/
public static void main(String[] theArgs) {
junit.awtui.TestRunner.main(new String[] {TestMessagesTag2.class.getName()});
}
/**
* @return a test suite (<code>TestSuite</code>) that includes all methods
* starting with "test"
*/
public static Test suite() {
// All methods starting with "test" will be executed in the test suite.
return new TestSuite(TestMessagesTag2.class);
}
private void runMyTest(String whichTest, String locale) throws Exception {
pageContext.setAttribute(Globals.LOCALE_KEY, new Locale(locale, locale), PageContext.SESSION_SCOPE);
request.setAttribute("runTest", whichTest);
pageContext.forward("/test/org/apache/struts/taglib/html/TestMessagesTag2.jsp");
}
/*
* Testing MessagesTag.
*/
public void testMessages() throws Exception {
runMyTest("testMessages", "");
}
public void testMessagesDefaultBundleEmpty() throws Exception {
runMyTest("testMessagesDefaultBundleEmpty", "");
}
public void testMessagesActionMessageDefaultBundle() throws Exception {
runMyTest("testMessagesActionMessageDefaultBundle", "");
}
public void testMessagesActionMessageDefaultBundleHeader() throws Exception {
runMyTest("testMessagesActionMessageDefaultBundleHeader", "");
}
public void testMessagesActionMessageDefaultBundleHeaderFooter() throws Exception {
runMyTest("testMessagesActionMessageDefaultBundleHeaderFooter", "");
}
public void testMessagesNameDefaultBundleEmpty() throws Exception {
runMyTest("testMessagesNameDefaultBundleEmpty", "");
}
public void testMessagesNamePropertyDefaultBundleEmpty() throws Exception {
runMyTest("testMessagesNamePropertyDefaultBundleEmpty", "");
}
public void testMessagesNameActionMessageDefaultBundle() throws Exception {
runMyTest("testMessagesNameActionMessageDefaultBundle", "");
}
public void testMessagesNamePropertyActionMessageDefaultBundle() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageDefaultBundle", "");
}
public void testMessagesNameActionMessageDefaultBundleHeader() throws Exception {
runMyTest("testMessagesNameActionMessageDefaultBundleHeader", "");
}
public void testMessagesNamePropertyActionMessageDefaultBundleHeader() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageDefaultBundleHeader", "");
}
public void testMessagesNameActionMessageDefaultBundleHeaderFooter() throws Exception {
runMyTest("testMessagesNameActionMessageDefaultBundleHeaderFooter", "");
}
public void testMessagesNamePropertyActionMessageDefaultBundleHeaderFooter() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageDefaultBundleHeaderFooter", "");
}
public void testMessagesAlternateBundleEmpty() throws Exception {
runMyTest("testMessagesAlternateBundleEmpty", "");
}
public void testMessagesActionMessageAlternateBundle() throws Exception {
runMyTest("testMessagesActionMessageAlternateBundle", "");
}
public void testMessagesActionMessageAlternateBundleHeader() throws Exception {
runMyTest("testMessagesActionMessageAlternateBundleHeader", "");
}
public void testMessagesActionMessageAlternateBundleHeaderFooter() throws Exception {
runMyTest("testMessagesActionMessageAlternateBundleHeaderFooter", "");
}
public void testMessagesNameAlternateBundleEmpty() throws Exception {
runMyTest("testMessagesNameAlternateBundleEmpty", "");
}
public void testMessagesNamePropertyAlternateBundleEmpty() throws Exception {
runMyTest("testMessagesNamePropertyAlternateBundleEmpty", "");
}
public void testMessagesNameActionMessageAlternateBundle() throws Exception {
runMyTest("testMessagesNameActionMessageAlternateBundle", "");
}
public void testMessagesNamePropertyActionMessageAlternateBundle() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageAlternateBundle", "");
}
public void testMessagesNameActionMessageAlternateBundleHeader() throws Exception {
runMyTest("testMessagesNameActionMessageAlternateBundleHeader", "");
}
public void testMessagesNamePropertyActionMessageAlternateBundleHeader() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageAlternateBundleHeader", "");
}
public void testMessagesNameActionMessageAlternateBundleHeaderFooter() throws Exception {
runMyTest("testMessagesNameActionMessageAlternateBundleHeaderFooter", "");
}
public void testMessagesNamePropertyActionMessageAlternateBundleHeaderFooter() throws Exception {
runMyTest("testMessagesNamePropertyActionMessageAlternateBundleHeaderFooter", "");
}
}
| {'content_hash': 'ec57fe42be7df7ef0888909bf69207ef', 'timestamp': '', 'source': 'github', 'line_count': 163, 'max_line_length': 108, 'avg_line_length': 32.90184049079755, 'alnum_prop': 0.7695319783703152, 'repo_name': 'codelibs/cl-struts', 'id': '8cdab04736b20d6ab97ad2c507c2b7ec7ca3c1a8', 'size': '6058', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/test/org/apache/struts/taglib/html/TestMessagesTag2.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'CSS', 'bytes': '42594'}, {'name': 'GAP', 'bytes': '7214'}, {'name': 'HTML', 'bytes': '17088052'}, {'name': 'Java', 'bytes': '6592773'}, {'name': 'XSLT', 'bytes': '36989'}]} |
package rere.sasl.scram.messages
import rere.sasl.util.{Base64String, PrintableAndSafe}
final case class ServerFirstMessage(
reserved: Option[AttrVal],
serverNonce: PrintableAndSafe,
salt: Base64String,
iterationCount: Int,
extensions: Seq[AttrVal])
| {'content_hash': 'b30249e63e704fc3eb60cb14c1b58833', 'timestamp': '', 'source': 'github', 'line_count': 10, 'max_line_length': 54, 'avg_line_length': 26.2, 'alnum_prop': 0.7900763358778626, 'repo_name': 'pbaun/rere', 'id': '1beabe1d12bb46ec7978262c554fbd5efa6551fd', 'size': '262', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'modules/sasl/src/main/scala/rere/sasl/scram/messages/ServerFirstMessage.scala', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Scala', 'bytes': '1082324'}]} |
import testlib
try:
from utils import *
except ImportError:
raise Exception("Add the SDK repository to your PYTHONPATH to run the examples "
"(e.g., export PYTHONPATH=~/splunk-sdk-python.")
TEST_DICT = {
'username':'admin',
'password':'changeme',
'port' : 8089,
'host' : 'localhost',
'scheme': 'https'
}
class TestUtils(testlib.SDKTestCase):
def setUp(self):
super(TestUtils, self).setUp()
# Test dslice when a dict is passed to change key names
def test_dslice_dict_args(self):
args = {
'username':'user-name',
'password':'new_password',
'port': 'admin_port',
'foo':'bar'
}
expected = {
'user-name':'admin',
'new_password':'changeme',
'admin_port':8089
}
self.assertTrue(expected == dslice(TEST_DICT, args))
# Test dslice when a list is passed
def test_dslice_list_args(self):
test_list = [
'username',
'password',
'port',
'host',
'foo'
]
expected = {
'username':'admin',
'password':'changeme',
'port':8089,
'host':'localhost'
}
self.assertTrue(expected == dslice(TEST_DICT, test_list))
# Test dslice when a single string is passed
def test_dslice_arg(self):
test_arg = 'username'
expected = {
'username':'admin'
}
self.assertTrue(expected == dslice(TEST_DICT, test_arg))
# Test dslice using all three types of arguments
def test_dslice_all_args(self):
test_args = [
{'username':'new_username'},
['password',
'host'],
'port'
]
expected = {
'new_username':'admin',
'password':'changeme',
'host':'localhost',
'port':8089
}
self.assertTrue(expected == dslice(TEST_DICT, *test_args))
if __name__ == "__main__":
try:
import unittest2 as unittest
except ImportError:
import unittest
unittest.main()
| {'content_hash': '665b300fedbe24cf4f126855c5a03c8a', 'timestamp': '', 'source': 'github', 'line_count': 84, 'max_line_length': 84, 'avg_line_length': 26.821428571428573, 'alnum_prop': 0.49533954727030627, 'repo_name': 'lowtalker/splunk-sdk-python', 'id': 'b5f3f4fb26a4c1c1675f39b136e28a7a4928e646', 'size': '2253', 'binary': False, 'copies': '2', 'ref': 'refs/heads/master', 'path': 'tests/test_utils.py', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Python', 'bytes': '628085'}]} |
package org.apache.pig.newplan.logical.relational;
import org.apache.hadoop.conf.Configuration;
import org.apache.pig.LoadFunc;
import org.apache.pig.impl.PigContext;
import org.apache.pig.impl.io.FileSpec;
public class LOTestHelper {
public static LOLoad newLOLoad(FileSpec loader, LogicalSchema schema, LogicalPlan plan, Configuration conf) {
LoadFunc loadFunc = null;
if (loader != null) {
loadFunc = (LoadFunc)PigContext.instantiateFuncFromSpec(loader.getFuncSpec());
}
return new LOLoad(loader, schema, plan, conf, loadFunc, "alias_newOperatorKey");
}
}
| {'content_hash': '81fdcb29d80e92032443ce58f418c2b3', 'timestamp': '', 'source': 'github', 'line_count': 18, 'max_line_length': 113, 'avg_line_length': 34.166666666666664, 'alnum_prop': 0.7252032520325203, 'repo_name': 'hxquangnhat/PIG-ROLLUP-AUTO-HII', 'id': '068644aa489d4ae14a39f0fab1f9a42e161b99d0', 'size': '1421', 'binary': False, 'copies': '28', 'ref': 'refs/heads/master', 'path': 'test/org/apache/pig/newplan/logical/relational/LOTestHelper.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'GAP', 'bytes': '327190'}, {'name': 'Java', 'bytes': '21674457'}, {'name': 'JavaScript', 'bytes': '4954'}, {'name': 'Perl', 'bytes': '241166'}, {'name': 'PigLatin', 'bytes': '253113'}, {'name': 'Python', 'bytes': '68412'}, {'name': 'Ruby', 'bytes': '38430'}, {'name': 'Shell', 'bytes': '81537'}, {'name': 'XSLT', 'bytes': '7913'}]} |
package com.thoughtworks.go.plugin.infra.listeners;
import com.thoughtworks.go.CurrentGoCDVersion;
import com.thoughtworks.go.plugin.FileHelper;
import com.thoughtworks.go.plugin.infra.PluginLoader;
import com.thoughtworks.go.plugin.infra.monitor.BundleOrPluginFileDetails;
import com.thoughtworks.go.plugin.infra.plugininfo.*;
import com.thoughtworks.go.util.SystemEnvironment;
import org.apache.commons.io.FileUtils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.osgi.framework.Bundle;
import java.io.File;
import java.io.IOException;
import java.util.List;
import static com.thoughtworks.go.util.SystemEnvironment.PLUGIN_ACTIVATOR_JAR_PATH;
import static com.thoughtworks.go.util.SystemEnvironment.PLUGIN_WORK_DIR;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;
class DefaultPluginJarChangeListenerTest {
private static final String PLUGIN_JAR_FILE_NAME = "descriptor-aware-test-plugin.jar";
private File pluginWorkDir;
private File bundleDir;
private DefaultPluginRegistry registry;
private GoPluginOSGiManifestGenerator osgiManifestGenerator;
private DefaultPluginJarChangeListener listener;
private PluginLoader pluginLoader;
private SystemEnvironment systemEnvironment;
private GoPluginBundleDescriptorBuilder goPluginBundleDescriptorBuilder;
private FileHelper temporaryFolder;
@BeforeEach
void setUp(@TempDir File rootDir) {
temporaryFolder = new FileHelper(rootDir);
bundleDir = temporaryFolder.newFolder("bundleDir");
pluginWorkDir = temporaryFolder.newFolder("pluginDir");
registry = mock(DefaultPluginRegistry.class);
osgiManifestGenerator = mock(GoPluginOSGiManifest.DefaultGoPluginOSGiManifestCreator.class);
pluginLoader = mock(PluginLoader.class);
goPluginBundleDescriptorBuilder = mock(GoPluginBundleDescriptorBuilder.class);
systemEnvironment = mock(SystemEnvironment.class);
when(systemEnvironment.get(PLUGIN_ACTIVATOR_JAR_PATH)).thenReturn("defaultFiles/go-plugin-activator.jar");
when(systemEnvironment.get(PLUGIN_WORK_DIR)).thenReturn(bundleDir.getAbsolutePath());
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Linux");
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
}
@Test
void shouldCopyPluginToBundlePathAndInformRegistryAndUpdateTheOSGiManifestWhenAPluginIsAdded() throws Exception {
String pluginId = "testplugin.descriptorValidator";
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File expectedBundleDirectory = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
String pluginJarFileLocation = pluginJarFile.getAbsolutePath();
GoPluginBundleDescriptor descriptor = new GoPluginBundleDescriptor(GoPluginDescriptor.builder()
.id(pluginId)
.bundleLocation(expectedBundleDirectory)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build());
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(descriptor);
when(registry.getPluginByIdOrFileName(pluginId, PLUGIN_JAR_FILE_NAME)).thenReturn(null);
doNothing().when(registry).loadPlugin(descriptor);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
assertThat(expectedBundleDirectory.exists()).isTrue();
verify(registry).getPluginByIdOrFileName(pluginId, PLUGIN_JAR_FILE_NAME);
verify(registry).loadPlugin(descriptor);
verify(osgiManifestGenerator).updateManifestOf(descriptor);
verify(pluginLoader).loadPlugin(descriptor);
verifyNoMoreInteractions(osgiManifestGenerator);
verifyNoMoreInteractions(registry);
assertThat(new File(expectedBundleDirectory, "lib/go-plugin-activator.jar").exists()).isTrue();
}
@Test
void shouldOverwriteAFileCalledGoPluginActivatorInLibWithOurOwnGoPluginActivatorEvenIfItExists() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File expectedBundleDirectory = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
File activatorFileLocation = new File(expectedBundleDirectory, "lib/go-plugin-activator.jar");
FileUtils.writeStringToFile(activatorFileLocation, "SOME-DATA", UTF_8);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
String pluginJarFileLocation = pluginJarFile.getAbsolutePath();
GoPluginBundleDescriptor descriptor = new GoPluginBundleDescriptor(GoPluginDescriptor.builder()
.id("testplugin.descriptorValidator")
.bundleLocation(expectedBundleDirectory)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build());
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(descriptor);
doNothing().when(registry).loadPlugin(descriptor);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
assertThat(new File(expectedBundleDirectory, "lib/go-plugin-activator.jar").exists()).isTrue();
assertThat(FileUtils.readFileToString(activatorFileLocation, UTF_8)).isNotEqualTo("SOME-DATA");
}
@Test
void shouldCopyPluginToBundlePathAndInformRegistryAndUpdateTheOSGiManifestWhenAPluginIsUpdated() throws IOException {
DefaultPluginJarChangeListener spy = spy(listener);
String pluginId = "plugin-id";
File oldFile = temporaryFolder.newFile("jar-name-1.0.0.jar");
File newBundleJarFile = temporaryFolder.newFile("jar-name-2.0.0.jar");
BundleOrPluginFileDetails oldBundleOrPluginJarFile = new BundleOrPluginFileDetails(oldFile, true, pluginWorkDir);
BundleOrPluginFileDetails newBundleOrPluginJarFile = new BundleOrPluginFileDetails(newBundleJarFile, true, pluginWorkDir);
GoPluginDescriptor oldDescriptor = GoPluginDescriptor.builder()
.id(pluginId)
.bundleLocation(oldBundleOrPluginJarFile.extractionLocation())
.isBundledPlugin(true)
.build();
GoPluginBundleDescriptor oldBundleDescriptor = new GoPluginBundleDescriptor(oldDescriptor);
GoPluginDescriptor newDescriptor = GoPluginDescriptor.builder()
.id(pluginId)
.bundleLocation(newBundleOrPluginJarFile.extractionLocation())
.isBundledPlugin(true)
.build();
GoPluginBundleDescriptor newBundleDescriptor = new GoPluginBundleDescriptor(newDescriptor);
doNothing().when(spy).explodePluginJarToBundleDir(newBundleJarFile, newBundleOrPluginJarFile.extractionLocation());
doNothing().when(spy).installActivatorJarToBundleDir(newBundleJarFile);
when(goPluginBundleDescriptorBuilder.build(newBundleOrPluginJarFile)).thenReturn(newBundleDescriptor);
when(registry.getPluginByIdOrFileName(pluginId, oldFile.getName())).thenReturn(oldDescriptor);
when(registry.unloadPlugin(newBundleDescriptor)).thenReturn(oldBundleDescriptor);
spy.pluginJarUpdated(newBundleOrPluginJarFile);
assertThat(oldBundleOrPluginJarFile.extractionLocation().exists()).isFalse();
verify(registry, atLeastOnce()).getPluginByIdOrFileName(pluginId, newBundleJarFile.getName());
verify(registry).unloadPlugin(newBundleDescriptor);
verify(registry).loadPlugin(newBundleDescriptor);
verify(osgiManifestGenerator).updateManifestOf(newBundleDescriptor);
verify(pluginLoader).unloadPlugin(oldBundleDescriptor);
verify(pluginLoader).loadPlugin(newBundleDescriptor);
verifyNoMoreInteractions(osgiManifestGenerator);
verifyNoMoreInteractions(registry);
}
@Test
void shouldRemovePluginFromBundlePathAndInformRegistryWhenAPluginIsRemoved() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File removedBundleDirectory = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
String pluginJarFileLocation = pluginJarFile.getAbsolutePath();
final GoPluginDescriptor descriptorOfThePluginWhichWillBeRemoved = GoPluginDescriptor.builder()
.id("testplugin.descriptorValidator")
.bundleLocation(removedBundleDirectory)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build();
GoPluginBundleDescriptor descriptorOfThePluginBundleWhichWillBeRemoved = new GoPluginBundleDescriptor(descriptorOfThePluginWhichWillBeRemoved);
when(registry.getPluginByIdOrFileName(null, descriptorOfThePluginWhichWillBeRemoved.fileName())).thenReturn(descriptorOfThePluginWhichWillBeRemoved);
when(registry.unloadPlugin(descriptorOfThePluginBundleWhichWillBeRemoved)).thenReturn(descriptorOfThePluginBundleWhichWillBeRemoved);
copyPluginToTheDirectory(bundleDir, PLUGIN_JAR_FILE_NAME);
listener.pluginJarRemoved(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry).unloadPlugin(descriptorOfThePluginBundleWhichWillBeRemoved);
verify(pluginLoader).unloadPlugin(descriptorOfThePluginBundleWhichWillBeRemoved);
assertThat(removedBundleDirectory.exists()).isFalse();
}
@Test
void shouldNotTryAndUpdateManifestOfAnAddedInvalidPlugin() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File expectedBundleDirectory = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
String pluginJarFileLocation = pluginJarFile.getAbsolutePath();
GoPluginBundleDescriptor descriptorForInvalidPlugin = new GoPluginBundleDescriptor(
GoPluginDescriptor.builder()
.id("testplugin.descriptorValidator")
.bundleLocation(expectedBundleDirectory)
.pluginJarFileLocation(pluginJarFileLocation)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build())
.markAsInvalid(singletonList("For a test"), null);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(descriptorForInvalidPlugin);
doNothing().when(registry).loadPlugin(descriptorForInvalidPlugin);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
assertThat(expectedBundleDirectory.exists()).isTrue();
verify(registry).loadPlugin(descriptorForInvalidPlugin);
verifyNoMoreInteractions(osgiManifestGenerator);
}
@Test
void shouldNotTryAndUpdateManifestOfAnUpdatedInvalidPlugin() throws Exception {
DefaultPluginJarChangeListener spy = spy(listener);
String pluginId = "plugin-id";
File pluginFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File expectedBundleDirectoryForInvalidPlugin = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
File bundleDirectoryForOldPlugin = new File(bundleDir, "descriptor-aware-test-plugin-old.jar");
FileUtils.forceMkdir(bundleDirectoryForOldPlugin);
String pluginJarFileLocation = pluginFile.getAbsolutePath();
GoPluginBundleDescriptor descriptorForInvalidPlugin = new GoPluginBundleDescriptor(GoPluginDescriptor.builder()
.id("testplugin.descriptorValidator")
.bundleLocation(expectedBundleDirectoryForInvalidPlugin)
.pluginJarFileLocation(pluginJarFileLocation)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build())
.markAsInvalid(singletonList("For a test"), null);
Bundle oldBundle = mock(Bundle.class);
final GoPluginDescriptor oldPluginDescriptor = GoPluginDescriptor.builder()
.id("some.old.id")
.bundleLocation(bundleDirectoryForOldPlugin)
.pluginJarFileLocation("some/path/to/plugin.jar")
.isBundledPlugin(true)
.build();
GoPluginBundleDescriptor oldBundleDescriptor = new GoPluginBundleDescriptor(oldPluginDescriptor).setBundle(oldBundle);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginFile, true, pluginWorkDir))).thenReturn(descriptorForInvalidPlugin);
when(registry.getPlugin(pluginId)).thenReturn(oldPluginDescriptor);
when(registry.unloadPlugin(descriptorForInvalidPlugin)).thenReturn(oldBundleDescriptor);
doNothing().when(registry).loadPlugin(descriptorForInvalidPlugin);
spy.pluginJarUpdated(new BundleOrPluginFileDetails(pluginFile, true, pluginWorkDir));
assertThat(expectedBundleDirectoryForInvalidPlugin.exists()).isTrue();
assertThat(bundleDirectoryForOldPlugin.exists()).isFalse();
verify(registry).unloadPlugin(descriptorForInvalidPlugin);
verify(pluginLoader).unloadPlugin(oldBundleDescriptor);
verify(registry).loadPlugin(descriptorForInvalidPlugin);
verifyNoMoreInteractions(osgiManifestGenerator);
verifyNoMoreInteractions(pluginLoader);
}
@Test
void shouldFailToLoadAPluginWhenActivatorJarIsNotAvailable() throws Exception {
systemEnvironment = mock(SystemEnvironment.class);
when(systemEnvironment.get(PLUGIN_ACTIVATOR_JAR_PATH)).thenReturn("some-path-which-does-not-exist.jar");
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
File bundleDirectory = new File(bundleDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
String pluginJarFileLocation = pluginJarFile.getAbsolutePath();
GoPluginDescriptor descriptor = GoPluginDescriptor.builder()
.id("some.old.id")
.bundleLocation(bundleDirectory)
.pluginJarFileLocation(pluginJarFileLocation)
.isBundledPlugin(true)
.build();
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(new GoPluginBundleDescriptor(descriptor));
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
assertThatCode(() -> listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir)))
.isInstanceOf(RuntimeException.class);
}
@Test
void shouldNotReplaceBundledPluginWhenExternalPluginIsAdded() {
String pluginId = "external";
String pluginJarFileName = "plugin-file-name";
File pluginJarFile = mock(File.class);
when(pluginJarFile.getName()).thenReturn(pluginJarFileName);
GoPluginBundleDescriptor externalPluginDescriptor = new GoPluginBundleDescriptor(getPluginDescriptor(pluginId, "1.0", pluginJarFileName, pluginJarFile, false, null));
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir))).thenReturn(externalPluginDescriptor);
GoPluginDescriptor bundledPluginDescriptor = getPluginDescriptor("bundled", "1.0", "1.0", null, true, null);
when(registry.getPluginByIdOrFileName(pluginId, pluginJarFileName)).thenReturn(bundledPluginDescriptor);
DefaultPluginJarChangeListener spy = spy(listener);
try {
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir));
fail("should have failed as external plugin cannot replace bundled plugin");
} catch (RuntimeException e) {
assertThat(e.getMessage()).isEqualTo("Found bundled plugin with ID: [bundled], external plugin could not be loaded");
}
verify(spy, never()).explodePluginJarToBundleDir(pluginJarFile, externalPluginDescriptor.bundleLocation());
}
private GoPluginDescriptor getPluginDescriptor(String pluginId,
String version,
String pluginJarLocation,
File bundleLocation,
boolean isBundledPlugin,
String targetGoVersion,
String... operatingSystems) {
return GoPluginDescriptor.builder()
.id(pluginId)
.version("1")
.pluginJarFileLocation(pluginJarLocation)
.bundleLocation(bundleLocation)
.isBundledPlugin(isBundledPlugin)
.about(GoPluginDescriptor.About.builder()
.version(version)
.targetGoVersion(targetGoVersion)
.targetOperatingSystems(List.of(operatingSystems))
.build())
.build();
}
@Test
void shouldFailIfAtleastOnePluginFromExternalPluginBundleTriesToReplaceGoCDInternalBundledPlugins_WhenAdding() {
final String filename = "plugin-file-name.jar";
File newPluginJarFile = new File("/path/to/" + filename);
final File bundleLocation = new File("/some/path/" + filename);
final GoPluginDescriptor newPluginDescriptor1 = getPluginDescriptor("external.1", "1.0", newPluginJarFile.getAbsolutePath(), bundleLocation, false, null);
final GoPluginDescriptor newPluginDescriptor2 = getPluginDescriptor("bundled", "1.0", newPluginJarFile.getAbsolutePath(), bundleLocation, false, null);
GoPluginBundleDescriptor newExternalPluginBundleDescriptor = new GoPluginBundleDescriptor(newPluginDescriptor1, newPluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(newPluginJarFile, false, pluginWorkDir))).thenReturn(newExternalPluginBundleDescriptor);
final GoPluginDescriptor existingPluginDescriptor1 = getPluginDescriptor("bundled", "1.0", "/some/path/file.jar", new File("/some/file.jar"), true, null);
when(registry.getPluginByIdOrFileName("external.1", filename)).thenReturn(null);
when(registry.getPluginByIdOrFileName("bundled", filename)).thenReturn(existingPluginDescriptor1);
DefaultPluginJarChangeListener spy = spy(listener);
try {
spy.pluginJarAdded(new BundleOrPluginFileDetails(newPluginJarFile, false, pluginWorkDir));
fail("should have failed as external plugin cannot replace bundled plugin");
} catch (RuntimeException e) {
assertThat(e.getMessage()).isEqualTo("Found bundled plugin with ID: [bundled], external plugin could not be loaded");
}
verify(spy, never()).explodePluginJarToBundleDir(newPluginJarFile, newExternalPluginBundleDescriptor.bundleLocation());
}
@Test
void shouldNotUpdatePluginWhenThereIsExistingPluginWithSameId() {
String pluginId = "plugin-id";
String pluginJarFileName = "plugin-file-name";
File pluginJarFile = mock(File.class);
when(pluginJarFile.getName()).thenReturn(pluginJarFileName);
final GoPluginDescriptor pluginDescriptor1 = getPluginDescriptor("some-new-plugin-id", "1.0", pluginJarFileName, pluginJarFile, true, null);
final GoPluginDescriptor pluginDescriptor2 = getPluginDescriptor(pluginId, "1.0", pluginJarFileName, pluginJarFile, true, null);
GoPluginBundleDescriptor newPluginDescriptor = new GoPluginBundleDescriptor(pluginDescriptor1, pluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir))).thenReturn(newPluginDescriptor);
final GoPluginDescriptor oldPluginDescriptor = getPluginDescriptor(pluginId, "1.0", "location-old", new File("location-old"), true, null);
when(registry.getPluginByIdOrFileName(pluginId, pluginJarFileName)).thenReturn(oldPluginDescriptor);
DefaultPluginJarChangeListener spy = spy(listener);
try {
spy.pluginJarUpdated(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir));
fail("should have failed as external plugin cannot replace bundled plugin");
} catch (RuntimeException e) {
assertThat(e.getMessage()).isEqualTo("Found another plugin with ID: plugin-id");
}
verify(spy, never()).explodePluginJarToBundleDir(pluginJarFile, newPluginDescriptor.bundleLocation());
}
@Test
void shouldNotUpdateBundledPluginWithExternalPlugin() {
String pluginId = "plugin-id";
String pluginJarFileName = "plugin-file-name.jar";
File pluginJarFile = new File("/some/path/" + pluginJarFileName);
BundleOrPluginFileDetails bundleOrPluginJarFile = new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir);
GoPluginBundleDescriptor newPluginDescriptor = new GoPluginBundleDescriptor(getPluginDescriptor(pluginId, "1.0", pluginJarFileName, bundleOrPluginJarFile.extractionLocation(), false, null));
when(goPluginBundleDescriptorBuilder.build(bundleOrPluginJarFile)).thenReturn(newPluginDescriptor);
GoPluginDescriptor oldPluginDescriptor = getPluginDescriptor(pluginId, "1.0", null, null, true, null);
when(registry.getPluginByIdOrFileName(pluginId, pluginJarFileName)).thenReturn(oldPluginDescriptor);
DefaultPluginJarChangeListener spy = spy(listener);
try {
spy.pluginJarUpdated(bundleOrPluginJarFile);
fail("should have failed as external plugin cannot replace bundled plugin");
} catch (RuntimeException e) {
assertThat(e.getMessage()).isEqualTo("Found bundled plugin with ID: [plugin-id], external plugin could not be loaded");
}
verify(spy, never()).explodePluginJarToBundleDir(pluginJarFile, newPluginDescriptor.bundleLocation());
}
@Test
void shouldFailIfAtleastOnePluginFromExternalPluginBundleTriesToReplaceGoCDInternalBundledPlugins_WhenUpdating() {
final String filename = "plugin-file-name.jar";
File updatedPluginJarLocation = new File("/path/to/" + filename);
File bundleLocation = new File("/some/path/" + filename);
final GoPluginDescriptor newPluginDescriptor1 = getPluginDescriptor("external.1", "1.0", updatedPluginJarLocation.getAbsolutePath(), bundleLocation, false, null);
final GoPluginDescriptor newPluginDescriptor2 = getPluginDescriptor("bundled", "1.0", updatedPluginJarLocation.getAbsolutePath(), bundleLocation, false, null);
GoPluginBundleDescriptor newExternalPluginBundleDescriptor = new GoPluginBundleDescriptor(newPluginDescriptor1, newPluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(updatedPluginJarLocation, false, pluginWorkDir))).thenReturn(newExternalPluginBundleDescriptor);
final GoPluginDescriptor existingPluginDescriptor1 = getPluginDescriptor("bundled", "1.0", updatedPluginJarLocation.getAbsolutePath(), bundleLocation, true, null);
when(registry.getPluginByIdOrFileName("external.1", filename)).thenReturn(null);
when(registry.getPluginByIdOrFileName("bundled", filename)).thenReturn(existingPluginDescriptor1);
DefaultPluginJarChangeListener spy = spy(listener);
try {
spy.pluginJarUpdated(new BundleOrPluginFileDetails(updatedPluginJarLocation, false, pluginWorkDir));
fail("should have failed as external plugin cannot replace bundled plugin");
} catch (RuntimeException e) {
assertThat(e.getMessage()).isEqualTo("Found bundled plugin with ID: [bundled], external plugin could not be loaded");
}
verify(spy, never()).explodePluginJarToBundleDir(updatedPluginJarLocation, newExternalPluginBundleDescriptor.bundleLocation());
}
@Test
void shouldNotRemoveBundledPluginExternalPluginJarRemovedWithSameId() {
String pluginId = "plugin-id";
String pluginJarFileName = "plugin-file-name";
File pluginJarFile = mock(File.class);
when(pluginJarFile.getName()).thenReturn(pluginJarFileName);
when(pluginJarFile.getAbsoluteFile()).thenReturn(new File(pluginJarFileName));
final GoPluginDescriptor oldPluginDescriptor = getPluginDescriptor(pluginId, "1.0", null, null, true, null);
GoPluginBundleDescriptor oldPluginBundleDescriptor = new GoPluginBundleDescriptor(oldPluginDescriptor);
when(registry.getPluginByIdOrFileName(null, pluginJarFileName)).thenReturn(oldPluginDescriptor);
DefaultPluginJarChangeListener spy = spy(listener);
spy.pluginJarRemoved(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir));
verify(registry, never()).unloadPlugin(oldPluginBundleDescriptor);
verify(pluginLoader, never()).unloadPlugin(oldPluginBundleDescriptor);
}
@Test
void shouldNotLoadAPluginWhenCurrentOSIsNotAmongTheListOfTargetOSesAsDeclaredByThePluginInItsXML() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
final GoPluginDescriptor pluginDescriptor1 = getPluginDescriptor("some.old.id.1", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, null, "Windows");
final GoPluginDescriptor pluginDescriptor2 = getPluginDescriptor("some.old.id.2", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, null, "Linux", "Mac OS X");
GoPluginBundleDescriptor bundleDescriptor = new GoPluginBundleDescriptor(pluginDescriptor1, pluginDescriptor2);
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Windows");
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(bundleDescriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(bundleDescriptor);
verifyZeroInteractions(pluginLoader);
assertThat(pluginDescriptor1.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor1.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with current operating system 'Windows'. Valid operating systems are: [Linux, Mac OS X].");
assertThat(pluginDescriptor2.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor2.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with current operating system 'Windows'. Valid operating systems are: [Linux, Mac OS X].");
}
@Test
void shouldNotLoadAPluginWhenCurrentOSIsNotAmongTheListOfTargetOSesAsDeclaredByThePluginInItsXMLForUpdatePath() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
String pluginID = "some.id";
final GoPluginDescriptor pluginDescriptor1 = getPluginDescriptor("some.old.id.1", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, null, "Linux");
final GoPluginDescriptor pluginDescriptor2 = getPluginDescriptor("some.old.id.2", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, null, "Windows", "Mac OS X");
GoPluginBundleDescriptor newBundleDescriptor = new GoPluginBundleDescriptor(pluginDescriptor1, pluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, false, pluginWorkDir))).thenReturn(newBundleDescriptor);
GoPluginBundleDescriptor oldPluginDescriptor = new GoPluginBundleDescriptor(getPluginDescriptor(pluginID, "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), true, null, "Linux", "Mac OS X"));
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Linux");
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(newBundleDescriptor);
when(registry.unloadPlugin(newBundleDescriptor)).thenReturn(oldPluginDescriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(newBundleDescriptor);
assertThat(pluginDescriptor1.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor1.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with current operating system 'Linux'. Valid operating systems are: [Windows, Mac OS X].");
assertThat(pluginDescriptor2.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor2.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with current operating system 'Linux'. Valid operating systems are: [Windows, Mac OS X].");
}
@Test
void shouldLoadAPluginWhenCurrentOSIsAmongTheListOfTargetOSesAsDeclaredByThePluginInItsXML() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
GoPluginBundleDescriptor descriptor = new GoPluginBundleDescriptor(getPluginDescriptor("some.old.id", "1.0", pluginJarFile.getAbsolutePath(),
new File(PLUGIN_JAR_FILE_NAME), false, null, "Windows", "Linux"));
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Windows");
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(descriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(descriptor);
verify(pluginLoader, times(1)).loadPlugin(descriptor);
}
@Test
void shouldLoadAPluginWhenAListOfTargetOSesIsNotDeclaredByThePluginInItsXML() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
GoPluginBundleDescriptor descriptor = new GoPluginBundleDescriptor(getPluginDescriptor("some.old.id", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, null));
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Windows");
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(descriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(descriptor);
verify(pluginLoader, times(1)).loadPlugin(descriptor);
}
@Test
void shouldNotLoadAPluginWhenTargetedGocdVersionIsGreaterThanCurrentGocdVersion() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
final GoPluginDescriptor pluginDescriptor1 = getPluginDescriptor("some.old.id.1", "1.0", pluginJarFile.getAbsolutePath(),
new File(PLUGIN_JAR_FILE_NAME), false, "17.5.0", "Linux", "Mac OS X");
final GoPluginDescriptor pluginDescriptor2 = getPluginDescriptor("some.old.id.2", "1.0", pluginJarFile.getAbsolutePath(),
new File(PLUGIN_JAR_FILE_NAME), false, "9999.0.0", "Linux", "Mac OS X");
GoPluginBundleDescriptor bundleDescriptor = new GoPluginBundleDescriptor(pluginDescriptor1, pluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(bundleDescriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(bundleDescriptor);
verifyZeroInteractions(pluginLoader);
assertThat(pluginDescriptor1.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor1.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with GoCD version '" + CurrentGoCDVersion.getInstance().goVersion() + "'. Compatible version is: 9999.0.0.");
assertThat(pluginDescriptor2.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor2.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incompatible with GoCD version '" + CurrentGoCDVersion.getInstance().goVersion() + "'. Compatible version is: 9999.0.0.");
}
@Test
void shouldNotLoadAPluginWhenTargetedGocdVersionIsIncorrect() throws Exception {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
final GoPluginDescriptor pluginDescriptor1 = getPluginDescriptor("some.old.id.1", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, "17.5.0", "Linux", "Mac OS X");
final GoPluginDescriptor pluginDescriptor2 = getPluginDescriptor("some.old.id.2", "1.0", pluginJarFile.getAbsolutePath(), new File(PLUGIN_JAR_FILE_NAME), false, "9999.0.0.1.2", "Linux", "Mac OS X");
GoPluginBundleDescriptor bundleDescriptor = new GoPluginBundleDescriptor(pluginDescriptor1, pluginDescriptor2);
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(bundleDescriptor);
listener = new DefaultPluginJarChangeListener(registry, osgiManifestGenerator, pluginLoader, goPluginBundleDescriptorBuilder, systemEnvironment);
listener.pluginJarAdded(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir));
verify(registry, times(1)).loadPlugin(bundleDescriptor);
verifyZeroInteractions(pluginLoader);
assertThat(pluginDescriptor1.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor1.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incorrect target GoCD version (17.5.0 & 9999.0.0.1.2) specified.");
assertThat(pluginDescriptor2.getStatus().getMessages().size()).isEqualTo(1);
assertThat(pluginDescriptor2.getStatus().getMessages().get(0)).isEqualTo("Plugins with IDs ([some.old.id.1, some.old.id.2]) are not valid: Incorrect target GoCD version (17.5.0 & 9999.0.0.1.2) specified.");
}
@Test
void shouldNotLoadAPluginWhenProvidedExtensionVersionByThePluginIsNotSupportedByCurrentGoCDVersion() throws IOException {
File pluginJarFile = new File(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
copyPluginToTheDirectory(pluginWorkDir, PLUGIN_JAR_FILE_NAME);
GoPluginDescriptor descriptor = getPluginDescriptor("some.old.id", "1.0", null,
new File(PLUGIN_JAR_FILE_NAME), false, null, "Windows", "Linux");
when(systemEnvironment.getOperatingSystemFamilyName()).thenReturn("Windows");
when(goPluginBundleDescriptorBuilder.build(new BundleOrPluginFileDetails(pluginJarFile, true, pluginWorkDir))).thenReturn(new GoPluginBundleDescriptor(descriptor));
}
private void copyPluginToTheDirectory(File destinationDir, String destinationFilenameOfPlugin) throws IOException {
FileUtils.copyFile(pathOfFileInDefaultFiles("descriptor-aware-test-plugin.jar"), new File(destinationDir, destinationFilenameOfPlugin));
}
private File pathOfFileInDefaultFiles(String filePath) {
return new File(getClass().getClassLoader().getResource("defaultFiles/" + filePath).getFile());
}
}
| {'content_hash': '8228b98a5bfc269fde0d7e1c636b7093', 'timestamp': '', 'source': 'github', 'line_count': 599, 'max_line_length': 269, 'avg_line_length': 62.92320534223706, 'alnum_prop': 0.7401767000079594, 'repo_name': 'marques-work/gocd', 'id': '9c89adcb29683b1b418015e720f37c74112e96c2', 'size': '38292', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'plugin-infra/go-plugin-infra/src/test/java/com/thoughtworks/go/plugin/infra/listeners/DefaultPluginJarChangeListenerTest.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Batchfile', 'bytes': '466'}, {'name': 'CSS', 'bytes': '807605'}, {'name': 'FreeMarker', 'bytes': '9759'}, {'name': 'Groovy', 'bytes': '2317159'}, {'name': 'HTML', 'bytes': '641338'}, {'name': 'Java', 'bytes': '21014983'}, {'name': 'JavaScript', 'bytes': '2539248'}, {'name': 'NSIS', 'bytes': '23525'}, {'name': 'PowerShell', 'bytes': '691'}, {'name': 'Ruby', 'bytes': '1907011'}, {'name': 'Shell', 'bytes': '169586'}, {'name': 'TSQL', 'bytes': '200114'}, {'name': 'TypeScript', 'bytes': '3423163'}, {'name': 'XSLT', 'bytes': '203240'}]} |
package org.apache.shiro.crypto;
import org.apache.shiro.codec.CodecSupport;
import org.apache.shiro.util.ByteSource;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.Arrays;
import static junit.framework.Assert.assertTrue;
/**
* Test cases for the {@link BlowfishCipherService} class.
*
* @since 1.0
*/
public class BlowfishCipherServiceTest {
private static final String[] PLAINTEXTS = new String[]{
"Hello, this is a test.",
"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
};
@Test
public void testBlockOperations() {
BlowfishCipherService blowfish = new BlowfishCipherService();
byte[] key = blowfish.generateNewKey().getEncoded();
for (String plain : PLAINTEXTS) {
byte[] plaintext = CodecSupport.toBytes(plain);
ByteSource ciphertext = blowfish.encrypt(plaintext, key);
ByteSource decrypted = blowfish.decrypt(ciphertext.getBytes(), key);
assertTrue(Arrays.equals(plaintext, decrypted.getBytes()));
}
}
@Test
public void testStreamingOperations() {
BlowfishCipherService cipher = new BlowfishCipherService();
byte[] key = cipher.generateNewKey().getEncoded();
for (String plain : PLAINTEXTS) {
byte[] plaintext = CodecSupport.toBytes(plain);
InputStream plainIn = new ByteArrayInputStream(plaintext);
ByteArrayOutputStream cipherOut = new ByteArrayOutputStream();
cipher.encrypt(plainIn, cipherOut, key);
byte[] ciphertext = cipherOut.toByteArray();
InputStream cipherIn = new ByteArrayInputStream(ciphertext);
ByteArrayOutputStream plainOut = new ByteArrayOutputStream();
cipher.decrypt(cipherIn, plainOut, key);
byte[] decrypted = plainOut.toByteArray();
assertTrue(Arrays.equals(plaintext, decrypted));
}
}
}
| {'content_hash': '40aa7069bf52900614f7268427b14d48', 'timestamp': '', 'source': 'github', 'line_count': 63, 'max_line_length': 138, 'avg_line_length': 33.301587301587304, 'alnum_prop': 0.6754051477597712, 'repo_name': 'haxwell/apache-shiro-1.2.3', 'id': 'fe176a473e3ece4e9756a55133794a1359e6fc28', 'size': '2907', 'binary': False, 'copies': '16', 'ref': 'refs/heads/1.0.x', 'path': 'core/src/test/java/org/apache/shiro/crypto/BlowfishCipherServiceTest.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '2199315'}]} |
A mobile-focused, graceful and powerful front-end framework for faster and easier mobile web development, inspired by Twitter's <a href="http://twitter.github.com/bootstrap/">bootstrap</a>.
## 基础模板(Basic template)
## 示例(Examples)
### 移动网页(Mobile Web Page)
* Index Page
* Article Page
### 移动单页程序(Mobile Web App)
* Home
* Content
* List
### 浏览器和设备支持(Browser and device support)
* Android 2.3+
* iOS 5+
移动版Firefox和移动版IE不在支持范围内,如果后续市场情况变化再做相应考虑
### Customizing Bootstrap
自定义
| {'content_hash': 'ddcc90d5f3341e0fe8163d3fb6264696', 'timestamp': '', 'source': 'github', 'line_count': 28, 'max_line_length': 189, 'avg_line_length': 18.392857142857142, 'alnum_prop': 0.6854368932038835, 'repo_name': 'mob-framework/mob', 'id': 'ab6ea0d938ec448aa41813c6a6a4f0b425285d6c', 'size': '635', 'binary': False, 'copies': '2', 'ref': 'refs/heads/master', 'path': 'docs/index.md', 'mode': '33188', 'license': 'bsd-2-clause', 'language': [{'name': 'CSS', 'bytes': '310428'}, {'name': 'JavaScript', 'bytes': '865524'}, {'name': 'Makefile', 'bytes': '116'}]} |
REGISTRY?=k8s.gcr.io
ARCH?=amd64
OUT_DIR?=_output
LOCAL_OUTPUT_PATH=$(shell pwd)/../../../$(OUT_DIR)/local/bin/linux/$(ARCH)
DOCKERIZED_OUTPUT_PATH=$(shell pwd)/../../../$(OUT_DIR)/dockerized/bin/linux/$(ARCH)
GINKGO_BIN?=$(shell test -f $(LOCAL_OUTPUT_PATH)/ginkgo && echo $(LOCAL_OUTPUT_PATH)/ginkgo || echo $(DOCKERIZED_OUTPUT_PATH)/ginkgo)
KUBECTL_BIN?=$(shell test -f $(LOCAL_OUTPUT_PATH)/kubectl && echo $(LOCAL_OUTPUT_PATH)/kubectl || echo $(DOCKERIZED_OUTPUT_PATH)/kubectl)
E2E_TEST_BIN?=$(shell test -f $(LOCAL_OUTPUT_PATH)/e2e.test && echo $(LOCAL_OUTPUT_PATH)/e2e.test || echo $(DOCKERIZED_OUTPUT_PATH)/e2e.test)
CLUSTER_DIR?=$(shell pwd)/../../../cluster/
BASEIMAGE=k8s.gcr.io/debian-hyperkube-base-$(ARCH):0.12.1
TEMP_DIR:=$(shell mktemp -d -t conformanceXXXXXX)
all: build
build:
ifndef VERSION
$(error VERSION is undefined)
endif
cp -r ./* ${TEMP_DIR}
cp ${GINKGO_BIN} ${TEMP_DIR}
cp ${KUBECTL_BIN} ${TEMP_DIR}
cp ${E2E_TEST_BIN} ${TEMP_DIR}
cp -r ${CLUSTER_DIR} ${TEMP_DIR}/cluster
chmod a+rx ${TEMP_DIR}/ginkgo
chmod a+rx ${TEMP_DIR}/kubectl
chmod a+rx ${TEMP_DIR}/e2e.test
cd ${TEMP_DIR} && sed -i.back "s|BASEIMAGE|${BASEIMAGE}|g" Dockerfile
docker build --pull -t ${REGISTRY}/conformance-${ARCH}:${VERSION} ${TEMP_DIR}
rm -rf "${TEMP_DIR}"
push: build
docker push ${REGISTRY}/conformance-${ARCH}:${VERSION}
ifeq ($(ARCH),amd64)
docker rmi ${REGISTRY}/conformance:${VERSION} 2>/dev/null || true
docker tag ${REGISTRY}/conformance-${ARCH}:${VERSION} ${REGISTRY}/conformance:${VERSION}
docker push ${REGISTRY}/conformance:${VERSION}
endif
.PHONY: build push all
| {'content_hash': '6f278d2bad07dfcd2f01b4bc29621b2a', 'timestamp': '', 'source': 'github', 'line_count': 48, 'max_line_length': 141, 'avg_line_length': 33.5625, 'alnum_prop': 0.6784605834885165, 'repo_name': 'enisoc/kubernetes', 'id': 'e75871e6f20ddff396f52899ded86ffd26f405e8', 'size': '2347', 'binary': False, 'copies': '19', 'ref': 'refs/heads/master', 'path': 'cluster/images/conformance/Makefile', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'C', 'bytes': '2840'}, {'name': 'Dockerfile', 'bytes': '61390'}, {'name': 'Go', 'bytes': '46076482'}, {'name': 'HTML', 'bytes': '38'}, {'name': 'Lua', 'bytes': '17200'}, {'name': 'Makefile', 'bytes': '76592'}, {'name': 'PowerShell', 'bytes': '97180'}, {'name': 'Python', 'bytes': '3176190'}, {'name': 'Ruby', 'bytes': '430'}, {'name': 'Shell', 'bytes': '1561537'}, {'name': 'sed', 'bytes': '11992'}]} |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>lambek: Not compatible</title>
<link rel="shortcut icon" type="image/png" href="../../../../../favicon.png" />
<link href="../../../../../bootstrap.min.css" rel="stylesheet">
<link href="../../../../../bootstrap-custom.css" rel="stylesheet">
<link href="//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
<script src="../../../../../moment.min.js"></script>
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body>
<div class="container">
<div class="navbar navbar-default" role="navigation">
<div class="container-fluid">
<div class="navbar-header">
<a class="navbar-brand" href="../../../../.."><i class="fa fa-lg fa-flag-checkered"></i> Coq bench</a>
</div>
<div id="navbar" class="collapse navbar-collapse">
<ul class="nav navbar-nav">
<li><a href="../..">clean / released</a></li>
<li class="active"><a href="">8.11.0 / lambek - 8.8.0</a></li>
</ul>
</div>
</div>
</div>
<div class="article">
<div class="row">
<div class="col-md-12">
<a href="../..">« Up</a>
<h1>
lambek
<small>
8.8.0
<span class="label label-info">Not compatible</span>
</small>
</h1>
<p><em><script>document.write(moment("2020-03-06 01:30:14 +0000", "YYYY-MM-DD HH:mm:ss Z").fromNow());</script> (2020-03-06 01:30:14 UTC)</em><p>
<h2>Context</h2>
<pre># Packages matching: installed
# Name # Installed # Synopsis
base-bigarray base
base-threads base
base-unix base
conf-findutils 1 Virtual package relying on findutils
conf-m4 1 Virtual package relying on m4
coq 8.11.0 Formal proof management system
num 1.3 The legacy Num library for arbitrary-precision integer and rational arithmetic
ocaml 4.09.0 The OCaml compiler (virtual package)
ocaml-base-compiler 4.09.0 Official release 4.09.0
ocaml-config 1 OCaml Switch Configuration
ocamlfind 1.8.1 A library manager for OCaml
# opam file:
opam-version: "2.0"
maintainer: "[email protected]"
homepage: "https://github.com/coq-contribs/lambek"
license: "LGPL 2.1"
build: [make "-j%{jobs}%"]
install: [make "install"]
remove: ["rm" "-R" "%{lib}%/coq/user-contrib/Lambek"]
depends: [
"ocaml"
"coq" {>= "8.8" & < "8.9~"}
]
tags: [ "keyword: Computational linguistic" "keyword: categorial grammar" "keyword: Lambek calculus..." "category: Computer Science/Formal Languages Theory and Automata" "date: March-July 2003" ]
authors: [ "Houda Anoun <[email protected]>" "Pierre Castéran <[email protected]>" ]
bug-reports: "https://github.com/coq-contribs/lambek/issues"
dev-repo: "git+https://github.com/coq-contribs/lambek.git"
synopsis: "A Coq Toolkit for Lambek Calculus"
description: """
This library contains some definitions concerning Lambek calculus.
Three formalisations of this calculus are proposed, and also some certified
functions which translate derivations from one formalism to another.
Several derived properties are proved and also some meta-theorems.
Users can define their own lexicons and use the defined tactics to prove the
derivation of sentences in a particular system (L, NL, LP, NLP ...)"""
flags: light-uninstall
url {
src: "https://github.com/coq-contribs/lambek/archive/v8.8.0.tar.gz"
checksum: "md5=146faacbe12684fc70e5840a963313c3"
}
</pre>
<h2>Lint</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Dry install</h2>
<p>Dry install with the current Coq version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam install -y --show-action coq-lambek.8.8.0 coq.8.11.0</code></dd>
<dt>Return code</dt>
<dd>5120</dd>
<dt>Output</dt>
<dd><pre>[NOTE] Package coq is already installed (current version is 8.11.0).
The following dependencies couldn't be met:
- coq-lambek -> coq < 8.9~ -> ocaml < 4.06.0
base of this switch (use `--unlock-base' to force)
Your request can't be satisfied:
- No available version of coq satisfies the constraints
No solution found, exiting
</pre></dd>
</dl>
<p>Dry install without Coq/switch base, to test if the problem was incompatibility with the current Coq/OCaml version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam remove -y coq; opam install -y --show-action --unlock-base coq-lambek.8.8.0</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Install dependencies</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>0 s</dd>
</dl>
<h2>Install</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>0 s</dd>
</dl>
<h2>Installation size</h2>
<p>No files were installed.</p>
<h2>Uninstall</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Missing removes</dt>
<dd>
none
</dd>
<dt>Wrong removes</dt>
<dd>
none
</dd>
</dl>
</div>
</div>
</div>
<hr/>
<div class="footer">
<p class="text-center">
<small>Sources are on <a href="https://github.com/coq-bench">GitHub</a>. © Guillaume Claret.</small>
</p>
</div>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script src="../../../../../bootstrap.min.js"></script>
</body>
</html>
| {'content_hash': 'a3181430008d654a3f8b26bd6d72afae', 'timestamp': '', 'source': 'github', 'line_count': 169, 'max_line_length': 245, 'avg_line_length': 43.23668639053255, 'alnum_prop': 0.5576844122074723, 'repo_name': 'coq-bench/coq-bench.github.io', 'id': '81d52e21d03743d5e57252505830eb4ce5cf38b6', 'size': '7310', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'clean/Linux-x86_64-4.09.0-2.0.5/released/8.11.0/lambek/8.8.0.html', 'mode': '33188', 'license': 'mit', 'language': []} |
require 'spec_helper'
describe RedditKit::Client::Search, :vcr do
describe "#search" do
it "returns search results" do
results = RedditKit.search 'ruby'
expect(results).to_not be_empty
end
it "restricts searches to a specific subreddit" do
results = RedditKit.search 'ruby', :subreddit => 'ruby', :restrict_to_subreddit => true
non_ruby_link = results.find { |link| link.subreddit != 'ruby' }
expect(results).to_not be_empty
expect(non_ruby_link).to be_nil
end
it "returns a specific number of results" do
results = RedditKit.search 'ruby', :subreddit => 'ruby', :restrict_to_subreddit => true, :limit => 3
expect(results.length).to eq 3
end
end
end
| {'content_hash': '48ba1a48883d1c554c90c13b58ff8c70', 'timestamp': '', 'source': 'github', 'line_count': 25, 'max_line_length': 106, 'avg_line_length': 29.28, 'alnum_prop': 0.6543715846994536, 'repo_name': 'samsymons/RedditKit.rb', 'id': '4db19b473f7e6d642fcfd1797a2ab5425815b720', 'size': '732', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'spec/redditkit/client/search_spec.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Ruby', 'bytes': '145429'}]} |
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <set>
#include <string>
#include <vector>
#include <wrl/client.h>
#include <wrl/implements.h>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/metrics/statistics_recorder.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/bind.h"
#include "base/threading/thread_restrictions.h"
#include "base/win/scoped_hstring.h"
#include "base/win/windows_version.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/notifications/notification_display_service_tester.h"
#include "chrome/browser/notifications/notification_platform_bridge_win.h"
#include "chrome/browser/notifications/win/fake_itoastnotification.h"
#include "chrome/browser/notifications/win/fake_itoastnotifier.h"
#include "chrome/browser/notifications/win/notification_launch_id.h"
#include "chrome/browser/notifications/win/notification_util.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/notifications/notification_operation.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "content/public/test/browser_test.h"
namespace mswr = Microsoft::WRL;
namespace winui = ABI::Windows::UI;
namespace {
const char kLaunchId[] = "0|0|Default|0|https://example.com/|notification_id";
const char kLaunchIdButtonClick[] =
"1|0|0|Default|0|https://example.com/|notification_id";
const char kLaunchIdSettings[] =
"2|0|Default|0|https://example.com/|notification_id";
// Windows native notification have a dependency on WinRT (Win 8+) and the
// built in Notification Center. Although native notifications in Chrome are
// only available in Win 10+ we keep the minimum test coverage at Win 8 in case
// we decide to backport.
constexpr base::win::Version kMinimumWindowsVersion = base::win::Version::WIN8;
Profile* CreateTestingProfile(const base::FilePath& path) {
base::ScopedAllowBlockingForTesting allow_blocking;
ProfileManager* profile_manager = g_browser_process->profile_manager();
size_t starting_number_of_profiles = profile_manager->GetNumberOfProfiles();
if (!base::PathExists(path) && !base::CreateDirectory(path))
NOTREACHED() << "Could not create directory at " << path.MaybeAsASCII();
std::unique_ptr<Profile> profile =
Profile::CreateProfile(path, nullptr, Profile::CREATE_MODE_SYNCHRONOUS);
Profile* profile_ptr = profile.get();
profile_manager->RegisterTestingProfile(std::move(profile), true);
EXPECT_EQ(starting_number_of_profiles + 1,
profile_manager->GetNumberOfProfiles());
return profile_ptr;
}
Profile* CreateTestingProfile(const std::string& profile_name) {
base::FilePath path;
base::PathService::Get(chrome::DIR_USER_DATA, &path);
path = path.AppendASCII(profile_name);
return CreateTestingProfile(path);
}
std::wstring GetToastString(const std::wstring& notification_id,
const std::wstring& profile_id,
bool incognito) {
return base::StringPrintf(
LR"(<toast launch="0|0|%ls|%d|https://foo.com/|%ls"></toast>)",
profile_id.c_str(), incognito, notification_id.c_str());
}
} // namespace
class NotificationPlatformBridgeWinUITest : public InProcessBrowserTest {
public:
NotificationPlatformBridgeWinUITest() = default;
~NotificationPlatformBridgeWinUITest() override = default;
void SetUpOnMainThread() override {
display_service_tester_ =
std::make_unique<NotificationDisplayServiceTester>(
browser()->profile());
}
NotificationPlatformBridgeWin* GetBridge() {
return static_cast<NotificationPlatformBridgeWin*>(
g_browser_process->notification_platform_bridge());
}
void TearDownOnMainThread() override { display_service_tester_.reset(); }
void HandleOperation(const base::RepeatingClosure& quit_task,
NotificationOperation operation,
NotificationHandler::Type notification_type,
const GURL& origin,
const std::string& notification_id,
const absl::optional<int>& action_index,
const absl::optional<std::u16string>& reply,
const absl::optional<bool>& by_user) {
last_operation_ = operation;
last_notification_type_ = notification_type;
last_origin_ = origin;
last_notification_id_ = notification_id;
last_action_index_ = action_index;
last_reply_ = reply;
last_by_user_ = by_user;
quit_task.Run();
}
void DisplayedNotifications(const base::RepeatingClosure& quit_task,
std::set<std::string> displayed_notifications,
bool supports_synchronization) {
displayed_notifications_ = std::move(displayed_notifications);
quit_task.Run();
}
void ValidateLaunchId(const std::string& expected_launch_id,
const base::RepeatingClosure& quit_task,
const NotificationLaunchId& launch_id) {
ASSERT_TRUE(launch_id.is_valid());
ASSERT_STREQ(expected_launch_id.c_str(), launch_id.Serialize().c_str());
quit_task.Run();
}
void OnHistogramRecorded(const base::RepeatingClosure& quit_closure,
const char* histogram_name,
uint64_t name_hash,
base::HistogramBase::Sample sample) {
quit_closure.Run();
}
protected:
void ProcessLaunchIdViaCmdLine(const std::string& launch_id,
const std::string& inline_reply) {
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(
&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate clicks on the toast.
base::CommandLine command_line = base::CommandLine::FromString(L"");
command_line.AppendSwitchASCII(switches::kNotificationLaunchId, launch_id);
if (!inline_reply.empty()) {
command_line.AppendSwitchASCII(switches::kNotificationInlineReply,
inline_reply);
}
ASSERT_TRUE(NotificationPlatformBridgeWin::HandleActivation(command_line));
run_loop.Run();
}
bool ValidateNotificationValues(NotificationOperation operation,
NotificationHandler::Type notification_type,
const GURL& origin,
const std::string& notification_id,
const absl::optional<int>& action_index,
const absl::optional<std::u16string>& reply,
const absl::optional<bool>& by_user) {
return operation == last_operation_ &&
notification_type == last_notification_type_ &&
origin == last_origin_ && notification_id == last_notification_id_ &&
action_index == last_action_index_ && reply == last_reply_ &&
by_user == last_by_user_;
}
std::unique_ptr<NotificationDisplayServiceTester> display_service_tester_;
NotificationOperation last_operation_;
NotificationHandler::Type last_notification_type_;
GURL last_origin_;
std::string last_notification_id_;
absl::optional<int> last_action_index_;
absl::optional<std::u16string> last_reply_;
absl::optional<bool> last_by_user_;
std::set<std::string> displayed_notifications_;
bool delegate_called_ = false;
};
class FakeIToastActivatedEventArgs
: public Microsoft::WRL::RuntimeClass<
Microsoft::WRL::RuntimeClassFlags<
Microsoft::WRL::WinRt | Microsoft::WRL::InhibitRoOriginateError>,
winui::Notifications::IToastActivatedEventArgs> {
public:
explicit FakeIToastActivatedEventArgs(const std::wstring& args)
: arguments_(args) {}
FakeIToastActivatedEventArgs(const FakeIToastActivatedEventArgs&) = delete;
FakeIToastActivatedEventArgs& operator=(const FakeIToastActivatedEventArgs&) =
delete;
~FakeIToastActivatedEventArgs() override = default;
HRESULT STDMETHODCALLTYPE get_Arguments(HSTRING* value) override {
base::win::ScopedHString arguments =
base::win::ScopedHString::Create(arguments_);
*value = arguments.get();
return S_OK;
}
private:
std::wstring arguments_;
};
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, HandleEvent) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
const wchar_t kXmlDoc[] =
LR"(<toast launch="0|0|Default|0|https://example.com/|notification_id">
<visual>
<binding template="ToastGeneric">
<text>My Title</text>
<text placement="attribution">example.com</text>
</binding>
</visual>
<actions>
<action content="Click" arguments="args" activationType="foreground"/>
</actions>
</toast>
)";
FakeIToastNotification toast(kXmlDoc, L"tag");
FakeIToastActivatedEventArgs args(
L"1|1|0|Default|0|https://example.com/|notification_id");
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate clicks on the toast.
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
bridge->ForwardHandleEventForTesting(NotificationOperation::kClick, &toast,
&args, absl::nullopt);
run_loop.Run();
// Validate the click values.
EXPECT_EQ(NotificationOperation::kClick, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(1, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_EQ(absl::nullopt, last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, HandleActivation) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate notification activation.
base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
command_line.AppendSwitchNative(
switches::kNotificationLaunchId,
L"1|1|0|Default|0|https://example.com/|notification_id");
NotificationPlatformBridgeWin::HandleActivation(command_line);
run_loop.Run();
// Validate the values.
EXPECT_EQ(NotificationOperation::kClick, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(1, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_EQ(true, last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, HandleSettings) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
const wchar_t kXmlDoc[] =
LR"(<toast launch="0|0|Default|0|https://example.com/|notification_id">
<visual>
<binding template="ToastGeneric">
<text>My Title</text>
<text placement="attribution">example.com</text>
</binding>
</visual>
<actions>
<action content="settings" placement="contextMenu" activationType="foreground" arguments="2|0|Default|0|https://example.com/|notification_id"/>
</actions>
</toast>
)";
FakeIToastNotification toast(kXmlDoc, L"tag");
FakeIToastActivatedEventArgs args(
L"2|0|Default|0|https://example.com/|notification_id");
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate clicks on the toast.
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
bridge->ForwardHandleEventForTesting(NotificationOperation::kSettings, &toast,
&args, absl::nullopt);
run_loop.Run();
// Validate the click values.
EXPECT_EQ(NotificationOperation::kSettings, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(absl::nullopt, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_EQ(absl::nullopt, last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, HandleClose) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate notification close.
base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
command_line.AppendSwitchNative(
switches::kNotificationLaunchId,
L"3|0|Default|0|https://example.com/|notification_id");
NotificationPlatformBridgeWin::HandleActivation(command_line);
run_loop.Run();
// Validate the values.
EXPECT_EQ(NotificationOperation::kClose, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(absl::nullopt, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_EQ(true, last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, GetDisplayed) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
std::vector<mswr::ComPtr<winui::Notifications::IToastNotification>>
notifications;
bridge->SetDisplayedNotificationsForTesting(¬ifications);
// Validate that empty list of notifications show 0 results.
{
base::RunLoop run_loop;
bridge->GetDisplayed(
browser()->profile(),
base::BindOnce(
&NotificationPlatformBridgeWinUITest::DisplayedNotifications,
base::Unretained(this), run_loop.QuitClosure()));
run_loop.Run();
EXPECT_EQ(0U, displayed_notifications_.size());
}
// Add four items (two in each profile, one for each being incognito and one
// for each that is not).
bool incognito = true;
Profile* profile1 = CreateTestingProfile("P1");
notifications.push_back(Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P1i", L"P1", incognito), L"tag"));
notifications.push_back(Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P1reg", L"P1", !incognito), L"tag"));
Profile* profile2 = CreateTestingProfile("P2");
notifications.push_back(Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P2i", L"P2", incognito), L"tag"));
notifications.push_back(Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P2reg", L"P2", !incognito), L"tag"));
// Query for profile P1 in incognito (should return 1 item).
{
base::RunLoop run_loop;
bridge->GetDisplayed(
profile1->GetPrimaryOTRProfile(/*create_if_needed=*/true),
base::BindOnce(
&NotificationPlatformBridgeWinUITest::DisplayedNotifications,
base::Unretained(this), run_loop.QuitClosure()));
run_loop.Run();
EXPECT_EQ(1U, displayed_notifications_.size());
EXPECT_EQ(1U, displayed_notifications_.count("P1i"));
}
// Query for profile P1 not in incognito (should return 1 item).
{
base::RunLoop run_loop;
bridge->GetDisplayed(
profile1,
base::BindOnce(
&NotificationPlatformBridgeWinUITest::DisplayedNotifications,
base::Unretained(this), run_loop.QuitClosure()));
run_loop.Run();
EXPECT_EQ(1U, displayed_notifications_.size());
EXPECT_EQ(1U, displayed_notifications_.count("P1reg"));
}
// Query for profile P2 in incognito (should return 1 item).
{
base::RunLoop run_loop;
bridge->GetDisplayed(
profile2->GetPrimaryOTRProfile(/*create_if_needed=*/true),
base::BindOnce(
&NotificationPlatformBridgeWinUITest::DisplayedNotifications,
base::Unretained(this), run_loop.QuitClosure()));
run_loop.Run();
EXPECT_EQ(1U, displayed_notifications_.size());
EXPECT_EQ(1U, displayed_notifications_.count("P2i"));
}
// Query for profile P2 not in incognito (should return 1 item).
{
base::RunLoop run_loop;
bridge->GetDisplayed(
profile2,
base::BindOnce(
&NotificationPlatformBridgeWinUITest::DisplayedNotifications,
base::Unretained(this), run_loop.QuitClosure()));
run_loop.Run();
EXPECT_EQ(1U, displayed_notifications_.size());
EXPECT_EQ(1U, displayed_notifications_.count("P2reg"));
}
bridge->SetDisplayedNotificationsForTesting(nullptr);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest,
SynchronizeNotifications) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
std::map<NotificationPlatformBridgeWin::NotificationKeyType,
NotificationLaunchId>
expected_displayed_notifications;
bridge->SetExpectedDisplayedNotificationsForTesting(
&expected_displayed_notifications);
std::vector<mswr::ComPtr<winui::Notifications::IToastNotification>>
notifications;
bridge->SetDisplayedNotificationsForTesting(¬ifications);
notifications.push_back(Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P1i", L"Default", true), L"tag"));
expected_displayed_notifications[{/*profile_id=*/"Default",
/*notification_id=*/"P1i"}] =
GetNotificationLaunchId(notifications.back().Get());
expected_displayed_notifications[{/*profile_id=*/"Default",
/*notification_id=*/"P2i"}] =
GetNotificationLaunchId(
Microsoft::WRL::Make<FakeIToastNotification>(
GetToastString(L"P2i", L"Default", false), L"tag")
.Get());
base::RunLoop run_loop;
display_service_tester_->SetProcessNotificationOperationDelegate(
base::BindRepeating(&NotificationPlatformBridgeWinUITest::HandleOperation,
base::Unretained(this), run_loop.QuitClosure()));
// Simulate notifications synchronization.
bridge->SynchronizeNotificationsForTesting();
run_loop.Run();
std::map<NotificationPlatformBridgeWin::NotificationKeyType,
NotificationLaunchId>
actual_expected_displayed_notification =
bridge->GetExpectedDisplayedNotificationForTesting();
// Only one notification is displayed (P1i). As result, the synchronization
// will close the notification P2i.
ASSERT_EQ(1u, actual_expected_displayed_notification.size());
EXPECT_TRUE(actual_expected_displayed_notification.count(
{/*profile_id=*/"Default",
/*notification_id=*/"P1i"}));
// Validate the close event values.
EXPECT_EQ(NotificationOperation::kClose, last_operation_);
EXPECT_EQ("P2i", last_notification_id_);
EXPECT_EQ(absl::nullopt, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_EQ(true, last_by_user_);
bridge->SetDisplayedNotificationsForTesting(nullptr);
bridge->SetExpectedDisplayedNotificationsForTesting(nullptr);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest,
SynchronizeNotificationsAfterClose) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
FakeIToastNotifier notifier;
bridge->SetNotifierForTesting(¬ifier);
// Show a new notification.
message_center::Notification notification(
message_center::NOTIFICATION_TYPE_SIMPLE, "notification_id", u"Text1",
u"Text2", ui::ImageModel(), std::u16string(),
GURL("https://example.com/"), message_center::NotifierId(),
message_center::RichNotificationData(), nullptr);
base::RunLoop display_run_loop;
base::StatisticsRecorder::ScopedHistogramSampleObserver
display_histogram_observer(
"Notifications.Windows.DisplayStatus",
base::BindRepeating(
&NotificationPlatformBridgeWinUITest::OnHistogramRecorded,
base::Unretained(this), display_run_loop.QuitClosure()));
bridge->Display(NotificationHandler::Type::WEB_PERSISTENT,
browser()->profile(), notification, /*metadata=*/nullptr);
display_run_loop.Run();
// The notification should now be in the expected map.
EXPECT_EQ(1u, bridge->GetExpectedDisplayedNotificationForTesting().size());
// Close the notification
base::RunLoop close_run_loop;
base::StatisticsRecorder::ScopedHistogramSampleObserver
close_histogram_observer(
"Notifications.Windows.CloseStatus",
base::BindRepeating(
&NotificationPlatformBridgeWinUITest::OnHistogramRecorded,
base::Unretained(this), close_run_loop.QuitClosure()));
bridge->Close(browser()->profile(), notification.id());
close_run_loop.Run();
// Closing a notification should remove it from the expected map.
EXPECT_EQ(0u, bridge->GetExpectedDisplayedNotificationForTesting().size());
bridge->SetNotifierForTesting(nullptr);
}
// Test calling Display with a fake implementation of the Action Center
// and validate it gets the values expected.
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, DisplayWithFakeAC) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
NotificationPlatformBridgeWin* bridge = GetBridge();
ASSERT_TRUE(bridge);
FakeIToastNotifier notifier;
bridge->SetNotifierForTesting(¬ifier);
std::string launch_id_value = "0|0|P1|0|https://example.com/|notification_id";
NotificationLaunchId launch_id(launch_id_value);
ASSERT_TRUE(launch_id.is_valid());
auto notification = std::make_unique<message_center::Notification>(
message_center::NOTIFICATION_TYPE_SIMPLE, "notification_id", u"Text1",
u"Text2", ui::ImageModel(), std::u16string(),
GURL("https://example.com/"), message_center::NotifierId(),
message_center::RichNotificationData(), nullptr);
std::unique_ptr<NotificationCommon::Metadata> metadata;
Profile* profile = CreateTestingProfile("P1");
{
base::RunLoop run_loop;
notifier.SetNotificationShownCallback(base::BindRepeating(
&NotificationPlatformBridgeWinUITest::ValidateLaunchId,
base::Unretained(this), launch_id_value, run_loop.QuitClosure()));
bridge->Display(NotificationHandler::Type::WEB_PERSISTENT, profile,
*notification, std::move(metadata));
run_loop.Run();
}
bridge->SetNotifierForTesting(nullptr);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, CmdLineClick) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
ASSERT_NO_FATAL_FAILURE(ProcessLaunchIdViaCmdLine(kLaunchId, /*reply=*/""));
// Validate the click values.
EXPECT_EQ(NotificationOperation::kClick, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(absl::nullopt, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_TRUE(last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest,
CmdLineInlineReply) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
ASSERT_NO_FATAL_FAILURE(
ProcessLaunchIdViaCmdLine(kLaunchIdButtonClick, "Inline reply"));
// Validate the click values.
EXPECT_EQ(NotificationOperation::kClick, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(0, last_action_index_);
EXPECT_EQ(u"Inline reply", last_reply_);
EXPECT_TRUE(last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, CmdLineButton) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
ASSERT_NO_FATAL_FAILURE(
ProcessLaunchIdViaCmdLine(kLaunchIdButtonClick, /*reply=*/""));
// Validate the click values.
EXPECT_EQ(NotificationOperation::kClick, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(0, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_TRUE(last_by_user_);
}
IN_PROC_BROWSER_TEST_F(NotificationPlatformBridgeWinUITest, CmdLineSettings) {
if (base::win::GetVersion() < kMinimumWindowsVersion)
return;
ASSERT_NO_FATAL_FAILURE(
ProcessLaunchIdViaCmdLine(kLaunchIdSettings, /*reply=*/""));
// Validate the click values.
EXPECT_EQ(NotificationOperation::kSettings, last_operation_);
EXPECT_EQ(NotificationHandler::Type::WEB_PERSISTENT, last_notification_type_);
EXPECT_EQ(GURL("https://example.com/"), last_origin_);
EXPECT_EQ("notification_id", last_notification_id_);
EXPECT_EQ(absl::nullopt, last_action_index_);
EXPECT_EQ(absl::nullopt, last_reply_);
EXPECT_TRUE(last_by_user_);
}
| {'content_hash': '2275bc5169da1b6b4c524d51de7b221e', 'timestamp': '', 'source': 'github', 'line_count': 676, 'max_line_length': 146, 'avg_line_length': 39.078402366863905, 'alnum_prop': 0.6988302986713102, 'repo_name': 'chromium/chromium', 'id': 'ed8e70d127889c90f05aaf4985c61d874daf4880', 'size': '26417', 'binary': False, 'copies': '6', 'ref': 'refs/heads/main', 'path': 'chrome/browser/notifications/notification_platform_bridge_win_interactive_uitest.cc', 'mode': '33188', 'license': 'bsd-3-clause', 'language': []} |
<?php
$loader = include __DIR__ . '/../vendor/autoload.php';
$loader->add('PhpNamedTimeOffset\Test', __DIR__); | {'content_hash': '1b85b0f6d100b61eaba5758f470dafd6', 'timestamp': '', 'source': 'github', 'line_count': 4, 'max_line_length': 54, 'avg_line_length': 27.75, 'alnum_prop': 0.6306306306306306, 'repo_name': 'rupertchen/php-named-time-offset', 'id': 'c6136d90dbf0b8a9c4869868b5e4a6cc2fff5b15', 'size': '111', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'tests/bootstrap.php', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'PHP', 'bytes': '17441'}]} |
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
namespace Crypton.AvChat.Win.History
{
public class XmlHistoryProvider : IHistoryProvider
{
private string filepath = null;
public XmlHistoryProvider()
{
}
public ChatModel.ChatDocument Document
{
get;
set;
}
public DateTime Date
{
get;
set;
}
public string Name
{
get;
set;
}
private string initializeLogFilePath()
{
string historyDirectory = HistoryManager.HistoryDirectory;
// current chat user
string chatUser = Path.Combine(historyDirectory, ChatDispatcher.Singleton.Username ?? "other");
if (!Directory.Exists(chatUser))
Directory.CreateDirectory(chatUser);
// get current named directory
string nameDirectory = Path.Combine(chatUser, this.Name);
if (!Directory.Exists(nameDirectory))
Directory.CreateDirectory(nameDirectory);
// create dated file
string filename = string.Format("{0:0000}-{1:00}-{2:00}.{3:00}{4:00}{5:00}.xml", DateTime.Now.Year,
DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
string dateFile = Path.Combine(nameDirectory, filename);
return dateFile;
}
private StreamWriter AllocateLogFile()
{
StreamWriter output;
do
{
try
{
output = new StreamWriter(this.filepath, false, Encoding.UTF8);
break;
}
catch { }
}
while (true);
return output;
}
public void BeginHistoryLog()
{
if (Document == null)
throw new InvalidOperationException("ChatDocument is required (Document property)");
if (string.IsNullOrEmpty(this.Name))
throw new InvalidOperationException("Name is required (Name property)");
this.Date = DateTime.Now;
// init destination file stream
this.filepath = initializeLogFilePath();
Document.Nodes.OnChatNodeAdd += Nodes_OnChatNodeAdd;
}
private void Nodes_OnChatNodeAdd(ChatModel.ChatNode node)
{
this.Flush();
}
private XmlElement createDocumentElement(XmlDocument historyDocument)
{
XmlDeclaration xdec = historyDocument.CreateXmlDeclaration("1.0", null, null);
historyDocument.AppendChild(xdec);
XmlElement xd = historyDocument.CreateElement("History");
XmlAttribute xaDate = historyDocument.CreateAttribute("Date");
xaDate.Value = this.Date.ToString(CultureInfo.InvariantCulture);
xd.Attributes.Append(xaDate);
XmlAttribute xaName = historyDocument.CreateAttribute("Name");
xaName.Value = this.Name;
xd.Attributes.Append(xaName);
historyDocument.AppendChild(xd);
return xd;
}
private void saveNode(ChatModel.ChatNode node, XmlElement historyElement, XmlDocument historyDocument)
{
XmlElement xe = historyDocument.CreateElement("Entry");
using (StringWriter sw = new StringWriter())
{
XmlSerializer xs = new XmlSerializer(typeof(ChatModel.ChatNode));
xs.Serialize(sw, node);
string rawXml = sw.ToString();
int xdecEndIdx = rawXml.IndexOf("\r\n");
xe.InnerXml = rawXml.Substring(xdecEndIdx);
}
historyElement.AppendChild(xe);
}
public void EndHistoryLog()
{
this.Flush();
Document.Nodes.OnChatNodeAdd -= Nodes_OnChatNodeAdd;
}
public void Flush()
{
try
{
XmlDocument historyDocument = new XmlDocument();
XmlElement historyElement = this.createDocumentElement(historyDocument);
foreach (var node in this.Document.Nodes.ToArray())
{
this.saveNode(node, historyElement, historyDocument);
}
using (StreamWriter output = this.AllocateLogFile())
{
historyDocument.Save(output);
}
}
catch { }
}
}
}
| {'content_hash': '3946254060156409b7f6fa1292544839', 'timestamp': '', 'source': 'github', 'line_count': 151, 'max_line_length': 115, 'avg_line_length': 31.516556291390728, 'alnum_prop': 0.5545282622399664, 'repo_name': 'CryptonZylog/ueravchatclient', 'id': '4bd5729aa237e28e9b505ed31fa0adfb37331353', 'size': '4761', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'Crypton.AvChat.Win/History/XmlHistoryProvider.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C#', 'bytes': '487335'}, {'name': 'CSS', 'bytes': '1703'}, {'name': 'HTML', 'bytes': '22376'}, {'name': 'JavaScript', 'bytes': '138'}]} |
@interface TabBarViewController ()
@end
@implementation TabBarViewController
- (void)viewDidLoad {
[super viewDidLoad];
//主页
UIStoryboard *mainStroyBoard = [UIStoryboard storyboardWithName:@"Index" bundle:nil];
UINavigationController *mainNav = mainStroyBoard.instantiateInitialViewController;
//发现
UIStoryboard *discoverStroyBoard = [UIStoryboard storyboardWithName:@"FindView" bundle:nil];
UINavigationController *discoverNav = discoverStroyBoard.instantiateInitialViewController;
//我的
UIStoryboard *mineStroyBoard = [UIStoryboard storyboardWithName:@"Ower" bundle:nil];
UINavigationController *mineNav = mineStroyBoard.instantiateInitialViewController;
mainNav.tabBarItem.image = [UIImage imageNamed:@"ft_found_normal_ic"];
discoverNav.tabBarItem.image = [UIImage imageNamed:@"ft_home_normal_ic"];
mineNav.tabBarItem.image = [UIImage imageNamed:@"ft_person_normal_ic"];
//上左下右
mainNav.tabBarItem.imageInsets = UIEdgeInsetsMake(6, 0, -6, 0);
discoverNav.tabBarItem.imageInsets = UIEdgeInsetsMake(6, 0, -6, 0);
mineNav.tabBarItem.imageInsets = UIEdgeInsetsMake(6, 0, -6, 0);
mainNav.tabBarItem.selectedImage = [[UIImage imageNamed:@"ft_found_selected_ic"] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
discoverNav.tabBarItem.selectedImage = [[UIImage imageNamed:@"ft_home_selected_ic"] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
mineNav.tabBarItem.selectedImage = [[UIImage imageNamed:@"ft_person_selected_ic"] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
//添加被管理的视图控制器
self.viewControllers = @[mainNav, discoverNav, mineNav];
}
@end
| {'content_hash': 'ffd7a72c5f09062d2e3ddd5e7e04a86c', 'timestamp': '', 'source': 'github', 'line_count': 41, 'max_line_length': 147, 'avg_line_length': 41.80487804878049, 'alnum_prop': 0.7537922987164527, 'repo_name': 'BurapaLi/HaoppyWeekDayer', 'id': 'bb5d68c00470ebd2a0ec0bc584c86b81f5ca2b9e', 'size': '1934', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'HappyWeekDayer/Classes/main主要/Other/TabBarViewController.m', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Objective-C', 'bytes': '376557'}, {'name': 'Ruby', 'bytes': '57'}]} |
namespace Babylon
{
partial class TabControl
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Component Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.dgvTranslationLog = new System.Windows.Forms.DataGridView();
this.lblInstance = new System.Windows.Forms.Label();
this.pnlSubmitTranslation = new System.Windows.Forms.Panel();
this.label6 = new System.Windows.Forms.Label();
this.cmbTranslationTo = new System.Windows.Forms.ComboBox();
this.cmbTranslationFrom = new System.Windows.Forms.ComboBox();
this.label5 = new System.Windows.Forms.Label();
this.btnTranslationSubmitClose = new System.Windows.Forms.Button();
this.label4 = new System.Windows.Forms.Label();
this.label2 = new System.Windows.Forms.Label();
this.label1 = new System.Windows.Forms.Label();
this.label3 = new System.Windows.Forms.Label();
this.txtSubmitTranslationTranslation = new System.Windows.Forms.TextBox();
this.txtSubmitTranslationOrigonal = new System.Windows.Forms.TextBox();
this.txtSubmitTrasnlationEmail = new System.Windows.Forms.TextBox();
this.btnTranslationSubmitSubmit = new System.Windows.Forms.Button();
this.btnTrasnlationSubmitCancel = new System.Windows.Forms.Button();
this.btnSubmitTranslation = new System.Windows.Forms.Button();
((System.ComponentModel.ISupportInitialize)(this.dgvTranslationLog)).BeginInit();
this.pnlSubmitTranslation.SuspendLayout();
this.SuspendLayout();
//
// dgvTranslationLog
//
this.dgvTranslationLog.AllowUserToAddRows = false;
this.dgvTranslationLog.AllowUserToDeleteRows = false;
this.dgvTranslationLog.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.dgvTranslationLog.AutoSizeColumnsMode = System.Windows.Forms.DataGridViewAutoSizeColumnsMode.AllCells;
this.dgvTranslationLog.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllCells;
this.dgvTranslationLog.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
this.dgvTranslationLog.Location = new System.Drawing.Point(0, 36);
this.dgvTranslationLog.Name = "dgvTranslationLog";
this.dgvTranslationLog.Size = new System.Drawing.Size(650, 411);
this.dgvTranslationLog.TabIndex = 0;
//
// lblInstance
//
this.lblInstance.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
this.lblInstance.Location = new System.Drawing.Point(121, 3);
this.lblInstance.Name = "lblInstance";
this.lblInstance.Size = new System.Drawing.Size(526, 30);
this.lblInstance.TabIndex = 1;
this.lblInstance.Text = "Waiting for an instance...";
this.lblInstance.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// pnlSubmitTranslation
//
this.pnlSubmitTranslation.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.pnlSubmitTranslation.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
this.pnlSubmitTranslation.Controls.Add(this.label6);
this.pnlSubmitTranslation.Controls.Add(this.cmbTranslationTo);
this.pnlSubmitTranslation.Controls.Add(this.cmbTranslationFrom);
this.pnlSubmitTranslation.Controls.Add(this.label5);
this.pnlSubmitTranslation.Controls.Add(this.btnTranslationSubmitClose);
this.pnlSubmitTranslation.Controls.Add(this.label4);
this.pnlSubmitTranslation.Controls.Add(this.label2);
this.pnlSubmitTranslation.Controls.Add(this.label1);
this.pnlSubmitTranslation.Controls.Add(this.label3);
this.pnlSubmitTranslation.Controls.Add(this.txtSubmitTranslationTranslation);
this.pnlSubmitTranslation.Controls.Add(this.txtSubmitTranslationOrigonal);
this.pnlSubmitTranslation.Controls.Add(this.txtSubmitTrasnlationEmail);
this.pnlSubmitTranslation.Controls.Add(this.btnTranslationSubmitSubmit);
this.pnlSubmitTranslation.Controls.Add(this.btnTrasnlationSubmitCancel);
this.pnlSubmitTranslation.Location = new System.Drawing.Point(146, 125);
this.pnlSubmitTranslation.Name = "pnlSubmitTranslation";
this.pnlSubmitTranslation.Size = new System.Drawing.Size(363, 187);
this.pnlSubmitTranslation.TabIndex = 2;
this.pnlSubmitTranslation.Visible = false;
//
// label6
//
this.label6.Location = new System.Drawing.Point(214, 119);
this.label6.Name = "label6";
this.label6.Size = new System.Drawing.Size(28, 13);
this.label6.TabIndex = 15;
this.label6.Text = "To:";
this.label6.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// cmbTranslationTo
//
this.cmbTranslationTo.FormattingEnabled = true;
this.cmbTranslationTo.Location = new System.Drawing.Point(248, 116);
this.cmbTranslationTo.Name = "cmbTranslationTo";
this.cmbTranslationTo.Size = new System.Drawing.Size(100, 21);
this.cmbTranslationTo.TabIndex = 5;
//
// cmbTranslationFrom
//
this.cmbTranslationFrom.FormattingEnabled = true;
this.cmbTranslationFrom.Location = new System.Drawing.Point(98, 116);
this.cmbTranslationFrom.Name = "cmbTranslationFrom";
this.cmbTranslationFrom.Size = new System.Drawing.Size(100, 21);
this.cmbTranslationFrom.TabIndex = 4;
//
// label5
//
this.label5.Location = new System.Drawing.Point(12, 119);
this.label5.Name = "label5";
this.label5.Size = new System.Drawing.Size(79, 13);
this.label5.TabIndex = 12;
this.label5.Text = "Traslate From:";
this.label5.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// btnTranslationSubmitClose
//
this.btnTranslationSubmitClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
this.btnTranslationSubmitClose.BackColor = System.Drawing.Color.Red;
this.btnTranslationSubmitClose.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.btnTranslationSubmitClose.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.btnTranslationSubmitClose.Location = new System.Drawing.Point(330, 0);
this.btnTranslationSubmitClose.Name = "btnTranslationSubmitClose";
this.btnTranslationSubmitClose.Size = new System.Drawing.Size(31, 23);
this.btnTranslationSubmitClose.TabIndex = 11;
this.btnTranslationSubmitClose.TabStop = false;
this.btnTranslationSubmitClose.Text = "X";
this.btnTranslationSubmitClose.UseVisualStyleBackColor = false;
this.btnTranslationSubmitClose.Click += new System.EventHandler(this.btnTranslationSubmitClose_Click);
//
// label4
//
this.label4.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.label4.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64)))));
this.label4.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.label4.ForeColor = System.Drawing.Color.White;
this.label4.Location = new System.Drawing.Point(0, 0);
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(332, 23);
this.label4.TabIndex = 10;
this.label4.Text = "Submit Translation/Correction";
//
// label2
//
this.label2.Location = new System.Drawing.Point(12, 92);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(79, 13);
this.label2.TabIndex = 9;
this.label2.Text = "Email Address:";
this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// label1
//
this.label1.Location = new System.Drawing.Point(9, 40);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(82, 13);
this.label1.TabIndex = 8;
this.label1.Text = "Origonal Text:";
this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// label3
//
this.label3.Location = new System.Drawing.Point(22, 66);
this.label3.Name = "label3";
this.label3.Size = new System.Drawing.Size(69, 13);
this.label3.TabIndex = 7;
this.label3.Text = "Translation:";
this.label3.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
//
// txtSubmitTranslationTranslation
//
this.txtSubmitTranslationTranslation.Location = new System.Drawing.Point(97, 63);
this.txtSubmitTranslationTranslation.Name = "txtSubmitTranslationTranslation";
this.txtSubmitTranslationTranslation.Size = new System.Drawing.Size(251, 20);
this.txtSubmitTranslationTranslation.TabIndex = 2;
//
// txtSubmitTranslationOrigonal
//
this.txtSubmitTranslationOrigonal.Location = new System.Drawing.Point(97, 37);
this.txtSubmitTranslationOrigonal.Name = "txtSubmitTranslationOrigonal";
this.txtSubmitTranslationOrigonal.Size = new System.Drawing.Size(251, 20);
this.txtSubmitTranslationOrigonal.TabIndex = 1;
//
// txtSubmitTrasnlationEmail
//
this.txtSubmitTrasnlationEmail.Location = new System.Drawing.Point(97, 89);
this.txtSubmitTrasnlationEmail.Name = "txtSubmitTrasnlationEmail";
this.txtSubmitTrasnlationEmail.Size = new System.Drawing.Size(251, 20);
this.txtSubmitTrasnlationEmail.TabIndex = 3;
//
// btnTranslationSubmitSubmit
//
this.btnTranslationSubmitSubmit.Location = new System.Drawing.Point(164, 159);
this.btnTranslationSubmitSubmit.Name = "btnTranslationSubmitSubmit";
this.btnTranslationSubmitSubmit.Size = new System.Drawing.Size(103, 23);
this.btnTranslationSubmitSubmit.TabIndex = 6;
this.btnTranslationSubmitSubmit.Text = "Submit Translation";
this.btnTranslationSubmitSubmit.UseVisualStyleBackColor = true;
this.btnTranslationSubmitSubmit.Click += new System.EventHandler(this.btnTranslationSubmitSubmit_Click);
//
// btnTrasnlationSubmitCancel
//
this.btnTrasnlationSubmitCancel.Location = new System.Drawing.Point(273, 159);
this.btnTrasnlationSubmitCancel.Name = "btnTrasnlationSubmitCancel";
this.btnTrasnlationSubmitCancel.Size = new System.Drawing.Size(75, 23);
this.btnTrasnlationSubmitCancel.TabIndex = 7;
this.btnTrasnlationSubmitCancel.Text = "Cancel";
this.btnTrasnlationSubmitCancel.UseVisualStyleBackColor = true;
this.btnTrasnlationSubmitCancel.Click += new System.EventHandler(this.btnTranslationSubmitClose_Click);
//
// btnSubmitTranslation
//
this.btnSubmitTranslation.Location = new System.Drawing.Point(3, 3);
this.btnSubmitTranslation.Name = "btnSubmitTranslation";
this.btnSubmitTranslation.Size = new System.Drawing.Size(112, 30);
this.btnSubmitTranslation.TabIndex = 0;
this.btnSubmitTranslation.Text = "Submit Translation";
this.btnSubmitTranslation.UseVisualStyleBackColor = true;
this.btnSubmitTranslation.Click += new System.EventHandler(this.btnSubmitTranslation_Click);
//
// TabControl
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.BackColor = System.Drawing.SystemColors.Control;
this.Controls.Add(this.btnSubmitTranslation);
this.Controls.Add(this.pnlSubmitTranslation);
this.Controls.Add(this.lblInstance);
this.Controls.Add(this.dgvTranslationLog);
this.Name = "TabControl";
this.Size = new System.Drawing.Size(650, 450);
((System.ComponentModel.ISupportInitialize)(this.dgvTranslationLog)).EndInit();
this.pnlSubmitTranslation.ResumeLayout(false);
this.pnlSubmitTranslation.PerformLayout();
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.DataGridView dgvTranslationLog;
private System.Windows.Forms.Label lblInstance;
private System.Windows.Forms.Panel pnlSubmitTranslation;
private System.Windows.Forms.Button btnTranslationSubmitClose;
private System.Windows.Forms.Label label4;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.TextBox txtSubmitTranslationTranslation;
private System.Windows.Forms.TextBox txtSubmitTranslationOrigonal;
private System.Windows.Forms.TextBox txtSubmitTrasnlationEmail;
private System.Windows.Forms.Button btnTranslationSubmitSubmit;
private System.Windows.Forms.Button btnTrasnlationSubmitCancel;
private System.Windows.Forms.Button btnSubmitTranslation;
private System.Windows.Forms.Label label6;
private System.Windows.Forms.ComboBox cmbTranslationTo;
private System.Windows.Forms.ComboBox cmbTranslationFrom;
private System.Windows.Forms.Label label5;
}
}
| {'content_hash': '8de1af4488c9602ec0f5124e5c728df5', 'timestamp': '', 'source': 'github', 'line_count': 283, 'max_line_length': 184, 'avg_line_length': 56.522968197879855, 'alnum_prop': 0.6445361340335084, 'repo_name': 'ezsoftware/Babylon', 'id': 'c406203a3b086ff041a7a854193e3ca8bb15a151', 'size': '15998', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'TabControl.Designer.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C#', 'bytes': '54700'}]} |
<?xml version="1.0" encoding="utf-8"?>
<reflection>
<assemblies>
<assembly name="mscorlib">
<assemblydata version="4.0.0.0" culture="" key="00000000000000000400000000000000" hash="SHA1" />
<attributes>
<attribute>
<type api="T:System.Runtime.CompilerServices.ExtensionAttribute" ref="true" />
</attribute>
<attribute>
<type api="T:System.Runtime.InteropServices.GuidAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>BED7F4EA-1A96-11d2-8F08-00A0C9A6186D</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Runtime.InteropServices.ComVisibleAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>False</value>
</argument>
</attribute>
<attribute>
<type api="T:System.CLSCompliantAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Security.AllowPartiallyTrustedCallersAttribute" ref="true" />
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyTitleAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>mscorlib.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDescriptionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>mscorlib.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDefaultAliasAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>mscorlib.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyCompanyAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>Microsoft Corporation</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyProductAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>Microsoft® .NET Framework</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyCopyrightAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>© Microsoft Corporation. All rights reserved.</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyFileVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.6.81.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyInformationalVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.6.81.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Resources.SatelliteContractVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.0.0.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Resources.NeutralResourcesLanguageAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>en-US</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDelaySignAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyKeyFileAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>f:\dd\tools\devdiv\EcmaPublicKey.snk</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblySignatureKeyAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>002400000c800000140100000602000000240000525341310008000001000100613399aff18ef1a2c2514a273a42d9042b72321f1757102df9ebada69923e2738406c21e5b801552ab8d200a65a235e001ac9adc25f2d811eb09496a4c6a59d4619589c69f5baf0c4179a47311d92555cd006acc8b5959f2bd6e10e360c34537a1d266da8085856583c85d81da7f3ec01ed9564c58d93d713cd0172c8e23a10f0239b80c96b07736f5d8b022542a4e74251a5f432824318b3539a5a087f8e53d2f135f9ca47f3bb2e10aff0af0849504fb7cea3ff192dc8de0edad64c68efde34c56d302ad55fd6e80f302d5efcdeae953658d3452561b5f36c542efdbdd9f888538d374cef106acf7d93a4445c3c73cd911f0571aaf3d54da12b11ddec375b3</value>
</argument>
<argument>
<type api="T:System.String" ref="true" />
<value>a5a866e1ee186f807668209f3b11236ace5e21f117803a3143abb126dd035d7d2f876b6938aaf2ee3414d5420d753621400db44a49c486ce134300a2106adb6bdb433590fef8ad5c43cba82290dc49530effd86523d9483c00f458af46890036b0e2c61d077d7fbac467a506eba29e467a87198b053c749aa2a4d2840c784e6d</value>
</argument>
</attribute>
</attributes>
</assembly>
<assembly name="System.Core">
<assemblydata version="4.0.0.0" culture="" key="00000000000000000400000000000000" hash="SHA1" />
<attributes>
<attribute>
<type api="T:System.Runtime.CompilerServices.ExtensionAttribute" ref="true" />
</attribute>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
<attribute>
<type api="T:System.Runtime.InteropServices.ComVisibleAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>False</value>
</argument>
</attribute>
<attribute>
<type api="T:System.CLSCompliantAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Security.AllowPartiallyTrustedCallersAttribute" ref="true" />
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyTitleAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>System.Core.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDescriptionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>System.Core.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDefaultAliasAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>System.Core.dll</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyCompanyAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>Microsoft Corporation</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyProductAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>Microsoft® .NET Framework</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyCopyrightAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>© Microsoft Corporation. All rights reserved.</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyFileVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.6.81.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyInformationalVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.6.81.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Resources.SatelliteContractVersionAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>4.0.0.0</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Resources.NeutralResourcesLanguageAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>en-US</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyDelaySignAttribute" ref="true" />
<argument>
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblyKeyFileAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>f:\dd\tools\devdiv\EcmaPublicKey.snk</value>
</argument>
</attribute>
<attribute>
<type api="T:System.Reflection.AssemblySignatureKeyAttribute" ref="true" />
<argument>
<type api="T:System.String" ref="true" />
<value>002400000c800000140100000602000000240000525341310008000001000100613399aff18ef1a2c2514a273a42d9042b72321f1757102df9ebada69923e2738406c21e5b801552ab8d200a65a235e001ac9adc25f2d811eb09496a4c6a59d4619589c69f5baf0c4179a47311d92555cd006acc8b5959f2bd6e10e360c34537a1d266da8085856583c85d81da7f3ec01ed9564c58d93d713cd0172c8e23a10f0239b80c96b07736f5d8b022542a4e74251a5f432824318b3539a5a087f8e53d2f135f9ca47f3bb2e10aff0af0849504fb7cea3ff192dc8de0edad64c68efde34c56d302ad55fd6e80f302d5efcdeae953658d3452561b5f36c542efdbdd9f888538d374cef106acf7d93a4445c3c73cd911f0571aaf3d54da12b11ddec375b3</value>
</argument>
<argument>
<type api="T:System.String" ref="true" />
<value>a5a866e1ee186f807668209f3b11236ace5e21f117803a3143abb126dd035d7d2f876b6938aaf2ee3414d5420d753621400db44a49c486ce134300a2106adb6bdb433590fef8ad5c43cba82290dc49530effd86523d9483c00f458af46890036b0e2c61d077d7fbac467a506eba29e467a87198b053c749aa2a4d2840c784e6d</value>
</argument>
</attribute>
</attributes>
</assembly>
</assemblies>
<apis>
<api id="N:System.Threading.Tasks">
<topicdata group="api" />
<apidata name="System.Threading.Tasks" group="namespace" />
<elements>
<element api="T:System.Threading.Tasks.Task`1" />
<element api="T:System.Threading.Tasks.TaskFactory`1" />
<element api="T:System.Threading.Tasks.ParallelOptions" />
<element api="T:System.Threading.Tasks.Parallel" />
<element api="T:System.Threading.Tasks.ParallelLoopState" />
<element api="T:System.Threading.Tasks.ParallelLoopResult" />
<element api="T:System.Threading.Tasks.TaskStatus" />
<element api="T:System.Threading.Tasks.Task" />
<element api="T:System.Threading.Tasks.TaskCreationOptions" />
<element api="T:System.Threading.Tasks.TaskContinuationOptions" />
<element api="T:System.Threading.Tasks.TaskCanceledException" />
<element api="T:System.Threading.Tasks.TaskSchedulerException" />
<element api="T:System.Threading.Tasks.TaskFactory" />
<element api="T:System.Threading.Tasks.TaskScheduler" />
<element api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
<element api="T:System.Threading.Tasks.TaskCompletionSource`1" />
<element api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<element api="T:System.Threading.Tasks.TaskExtensions" />
</elements>
<file name="042b2d6e-6b05-f0d3-711c-2b8876b49dc3" />
</api>
<api id="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<apidata name="ConcurrentExclusiveSchedulerPair" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="9c590e20-fd53-8be4-07c1-c38c196e3dd1" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair">
<topicdata name="ConcurrentExclusiveSchedulerPair" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<apidata name="ConcurrentExclusiveSchedulerPair" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor">
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32)" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32)" />
</element>
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete" />
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Completion" />
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ConcurrentScheduler" />
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ExclusiveScheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
</containers>
<file name="e423b889-3d83-e56e-a35b-da668b4cbc3f" />
</api>
<api id="Methods.T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair">
<topicdata name="ConcurrentExclusiveSchedulerPair" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<apidata name="ConcurrentExclusiveSchedulerPair" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
</containers>
<file name="eb26300f-8add-3a74-9597-b7c87cd3aa55" />
</api>
<api id="Properties.T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair">
<topicdata name="ConcurrentExclusiveSchedulerPair" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<apidata name="ConcurrentExclusiveSchedulerPair" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<elements>
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Completion" />
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ConcurrentScheduler" />
<element api="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ExclusiveScheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
</containers>
<file name="7b6f48c3-c378-c5fc-837a-3fe787946a05" />
</api>
<api id="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32)" />
<element api="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="acb8dfa1-0a04-9029-eb36-810b8c24dd09" />
</api>
<api id="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="43f5f141-02c2-87b9-d8db-873c7e17a3f6" />
</api>
<api id="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<parameters>
<parameter name="taskScheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="eae6395b-de0f-0468-7698-2c8d75958095" />
</api>
<api id="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<parameters>
<parameter name="taskScheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
<parameter name="maxConcurrencyLevel">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="53c355a7-7663-4abc-9c9f-bc4e3a32b8e5" />
</api>
<api id="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor(System.Threading.Tasks.TaskScheduler,System.Int32,System.Int32)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.#ctor" />
<parameters>
<parameter name="taskScheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
<parameter name="maxConcurrencyLevel">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="maxItemsPerTask">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="0c669c0d-e7ce-a89d-b081-ff4e62962f2b" />
</api>
<api id="M:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Complete">
<topicdata group="api" />
<apidata name="Complete" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="6f515e65-46ce-a089-7173-474550a6b460" />
</api>
<api id="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.Completion">
<topicdata group="api" />
<apidata name="Completion" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Completion" />
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="f435f70c-be7d-24c6-00dc-6c40ec28c5cd" />
</api>
<api id="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ConcurrentScheduler">
<topicdata group="api" />
<apidata name="ConcurrentScheduler" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_ConcurrentScheduler" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="26a185ad-50a7-25a4-8cd8-c619cccd6b5e" />
</api>
<api id="P:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair.ExclusiveScheduler">
<topicdata group="api" />
<apidata name="ExclusiveScheduler" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_ExclusiveScheduler" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ConcurrentExclusiveSchedulerPair" ref="true" />
</containers>
<file name="04f8647d-9fe0-73c9-e827-bb3557b770dd" />
</api>
<api id="T:System.Threading.Tasks.Parallel">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Parallel" />
<apidata name="Parallel" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="2967d08c-c678-864e-b9de-96743de997ed" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.Parallel">
<topicdata name="Parallel" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.Parallel" />
<apidata name="Parallel" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<elements>
<element api="Overload:System.Threading.Tasks.Parallel.For">
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</element>
<element api="Overload:System.Threading.Tasks.Parallel.ForEach">
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</element>
<element api="Overload:System.Threading.Tasks.Parallel.Invoke">
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Action[])" />
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Threading.Tasks.ParallelOptions,System.Action[])" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" />
</containers>
<file name="a6a58b46-c9d3-85fc-0e11-c3bfa5620e8b" />
</api>
<api id="Methods.T:System.Threading.Tasks.Parallel">
<topicdata name="Parallel" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.Parallel" />
<apidata name="Parallel" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<elements>
<element api="Overload:System.Threading.Tasks.Parallel.For">
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</element>
<element api="Overload:System.Threading.Tasks.Parallel.ForEach">
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</element>
<element api="Overload:System.Threading.Tasks.Parallel.Invoke">
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Action[])" />
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Threading.Tasks.ParallelOptions,System.Action[])" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" />
</containers>
<file name="055cff68-1035-1a3c-d213-12dfcd6aa51b" />
</api>
<api id="Overload:System.Threading.Tasks.Parallel.For">
<topicdata name="For" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Parallel" />
<apidata name="For" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="6af5bd85-a85f-b3fc-4f4a-ec8e0283c365" />
</api>
<api id="Overload:System.Threading.Tasks.Parallel.ForEach">
<topicdata name="ForEach" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Parallel" />
<apidata name="ForEach" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<element api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="a5008326-c669-97ca-57fc-79dadda06314" />
</api>
<api id="Overload:System.Threading.Tasks.Parallel.Invoke">
<topicdata name="Invoke" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Parallel" />
<apidata name="Invoke" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Action[])" />
<element api="M:System.Threading.Tasks.Parallel.Invoke(System.Threading.Tasks.ParallelOptions,System.Action[])" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="0d18ef58-5fc8-bc28-48e7-432bcd3bf8b3" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="a12ba6fe-f26c-1614-c109-3ffbcada95cc" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="a386d59f-88b2-f1eb-c772-fcc8f2a6c932" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<templates>
<template name="TLocal" />
</templates>
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="8bb8606a-742b-f397-8b02-0871eaa29cd3" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="190e3717-057c-e698-062d-fe6d82fa5a4e" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Action{System.Int32,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="b3b1d664-9cdc-d088-3540-e5215a51d102" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<templates>
<template name="TLocal" />
</templates>
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<type api="T:System.Int32" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int32,System.Int32,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int32,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="a47f9912-5e3d-3ae0-a5ee-cbbc512b9f90" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="23f7a464-c5cc-f863-206d-fea0f4ae5ab2" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="6a2e14f2-6e10-f64c-0562-d8bb832be4fe" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<templates>
<template name="TLocal" />
</templates>
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="6e1c5ae3-7565-b9f4-01d1-a5dca11f2e9a" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="08274e1d-55df-90b1-0a7e-d9243171933b" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Action{System.Int64,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="ed818474-d702-8e32-357c-3e15baf11193" />
</api>
<api id="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="For" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.For" />
<proceduredata virtual="false" />
<templates>
<template name="TLocal" />
</templates>
<parameters>
<parameter name="fromInclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="toExclusive">
<type api="T:System.Int64" ref="false" />
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<type api="T:System.Int64" ref="false" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="0" api="M:System.Threading.Tasks.Parallel.For``1(System.Int64,System.Int64,System.Threading.Tasks.ParallelOptions,System.Func{``0},System.Func{System.Int64,System.Threading.Tasks.ParallelLoopState,``0,``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="3ef36f6d-0fe7-ad23-fcb4-4954402b270f" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.OrderablePartitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`3" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="6d186442-d225-6374-21f4-5ecb075e834d" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.OrderablePartitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="c53778ac-5035-6fea-62b3-ab9c3ba27326" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.OrderablePartitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`3" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="41b4f1ae-7af1-2b76-a014-3e743501e6b9" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.OrderablePartitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.OrderablePartitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="2618d311-a593-f28e-f575-53f0f560cc73" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="77914186-e44e-6b51-0ca6-189d5bd27e8b" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="05b74d6c-7290-27fd-8e0f-98e2d48b09a5" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="d56852d7-8c65-0d64-e182-c2babcef9dde" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="96fb4638-6448-4be0-e637-aba7f2b12564" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="9b8db047-c9e3-fc01-ce49-102236bb30c5" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Concurrent.Partitioner`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Concurrent.Partitioner{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="9d84bcae-02ad-3fd1-c25b-fb5f1730c904" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="9445ea10-024d-ba4f-b614-fe1ab47f7343" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="aab1223f-524c-7543-a895-396f27207190" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Action`3" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="98c8abb7-c294-4a35-8d4d-ef249f9ef93f" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="66d9e96e-5b17-f51c-932e-cb084da6c3c4" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="c714ee12-c61f-49b8-a65e-5f343bdd589f" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="dd864fd6-9250-5b1f-1049-8020ad1fe0a5" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`2" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="4e79e76c-52b5-57a4-0a61-ee5a6d626d41" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="body">
<type api="T:System.Action`3" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Action{``0,System.Threading.Tasks.ParallelLoopState,System.Int64})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="1feff57a-4b18-7a70-26e9-fe5dab2128ee" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="a0eeac4d-e97a-ec5c-9912-8e57b435f2b2" />
</api>
<api id="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})">
<topicdata group="api" />
<apidata name="ForEach" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.ForEach" />
<proceduredata virtual="false" />
<templates>
<template name="TSource" />
<template name="TLocal" />
</templates>
<parameters>
<parameter name="source">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="localInit">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="body">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TSource" index="0" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
<type api="T:System.Int64" ref="false" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
<parameter name="localFinally">
<type api="T:System.Action`1" ref="true">
<specialization>
<template name="TLocal" index="1" api="M:System.Threading.Tasks.Parallel.ForEach``2(System.Collections.Generic.IEnumerable{``0},System.Threading.Tasks.ParallelOptions,System.Func{``1},System.Func{``0,System.Threading.Tasks.ParallelLoopState,System.Int64,``1,``1},System.Action{``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="f30164ff-593f-a5d4-e7b4-d7e94f57fefd" />
</api>
<api id="M:System.Threading.Tasks.Parallel.Invoke(System.Action[])">
<topicdata group="api" />
<apidata name="Invoke" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.Invoke" />
<proceduredata virtual="false" />
<parameters>
<parameter name="actions" params="true">
<arrayOf rank="1">
<type api="T:System.Action" ref="true" />
</arrayOf>
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="c2d98cee-5bcf-418e-7397-2840d5131c57" />
</api>
<api id="M:System.Threading.Tasks.Parallel.Invoke(System.Threading.Tasks.ParallelOptions,System.Action[])">
<topicdata group="api" />
<apidata name="Invoke" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Parallel.Invoke" />
<proceduredata virtual="false" />
<parameters>
<parameter name="parallelOptions">
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</parameter>
<parameter name="actions" params="true">
<arrayOf rank="1">
<type api="T:System.Action" ref="true" />
</arrayOf>
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Parallel" ref="true" />
</containers>
<file name="e71a072a-d0cd-585c-a732-c015a707b257" />
</api>
<api id="T:System.Threading.Tasks.ParallelLoopResult">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.ParallelLoopResult" />
<apidata name="ParallelLoopResult" group="type" subgroup="structure" />
<typedata visibility="public" sealed="true" serializable="false" noSettableProperties="true" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="75f858ea-a4ba-ce29-97d7-3952cbd2629f" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.ParallelLoopResult">
<topicdata name="ParallelLoopResult" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.ParallelLoopResult" />
<apidata name="ParallelLoopResult" group="type" subgroup="structure" />
<typedata visibility="public" sealed="true" serializable="false" noSettableProperties="true" />
<elements>
<element api="M:System.Object.GetType" />
<element api="M:System.ValueType.Equals(System.Object)" />
<element api="M:System.ValueType.GetHashCode" />
<element api="M:System.ValueType.ToString" />
<element api="P:System.Threading.Tasks.ParallelLoopResult.IsCompleted" />
<element api="P:System.Threading.Tasks.ParallelLoopResult.LowestBreakIteration" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopResult" />
</containers>
<file name="01781818-b54c-1d14-d890-b849bd05a994" />
</api>
<api id="Methods.T:System.Threading.Tasks.ParallelLoopResult">
<topicdata name="ParallelLoopResult" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.ParallelLoopResult" />
<apidata name="ParallelLoopResult" group="type" subgroup="structure" />
<typedata visibility="public" sealed="true" serializable="false" noSettableProperties="true" />
<elements>
<element api="M:System.Object.GetType" />
<element api="M:System.ValueType.Equals(System.Object)" />
<element api="M:System.ValueType.GetHashCode" />
<element api="M:System.ValueType.ToString" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopResult" />
</containers>
<file name="12eabf57-bda6-5f89-5f73-2ec032894126" />
</api>
<api id="Properties.T:System.Threading.Tasks.ParallelLoopResult">
<topicdata name="ParallelLoopResult" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.ParallelLoopResult" />
<apidata name="ParallelLoopResult" group="type" subgroup="structure" />
<typedata visibility="public" sealed="true" serializable="false" noSettableProperties="true" />
<elements>
<element api="P:System.Threading.Tasks.ParallelLoopResult.IsCompleted" />
<element api="P:System.Threading.Tasks.ParallelLoopResult.LowestBreakIteration" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopResult" />
</containers>
<file name="9362824c-acc5-c8b6-f6c9-0e81b4db309f" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopResult.IsCompleted">
<topicdata group="api" />
<apidata name="IsCompleted" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_IsCompleted" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</containers>
<file name="d6e48391-0443-9cb6-d269-09d0cb53ddec" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopResult.LowestBreakIteration">
<topicdata group="api" />
<apidata name="LowestBreakIteration" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_LowestBreakIteration" />
<returns>
<type api="T:System.Nullable`1" ref="false">
<specialization>
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopResult" ref="false" />
</containers>
<file name="a7473f73-60ca-d137-8841-4434170b97d9" />
</api>
<api id="T:System.Threading.Tasks.ParallelLoopState">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.ParallelLoopState" />
<apidata name="ParallelLoopState" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="b94ab809-7d26-fa2e-4080-c7c90d3fb5e1" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.ParallelLoopState">
<topicdata name="ParallelLoopState" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.ParallelLoopState" />
<apidata name="ParallelLoopState" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.ParallelLoopState.Break" />
<element api="P:System.Threading.Tasks.ParallelLoopState.IsExceptional" />
<element api="P:System.Threading.Tasks.ParallelLoopState.IsStopped" />
<element api="P:System.Threading.Tasks.ParallelLoopState.LowestBreakIteration" />
<element api="P:System.Threading.Tasks.ParallelLoopState.ShouldExitCurrentIteration" />
<element api="M:System.Threading.Tasks.ParallelLoopState.Stop" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" />
</containers>
<file name="2f0719a1-3be9-dade-2eed-e004df980c0c" />
</api>
<api id="Methods.T:System.Threading.Tasks.ParallelLoopState">
<topicdata name="ParallelLoopState" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.ParallelLoopState" />
<apidata name="ParallelLoopState" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.ParallelLoopState.Break" />
<element api="M:System.Threading.Tasks.ParallelLoopState.Stop" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" />
</containers>
<file name="f99d490d-0152-a05e-b50b-9aa7b390ed97" />
</api>
<api id="Properties.T:System.Threading.Tasks.ParallelLoopState">
<topicdata name="ParallelLoopState" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.ParallelLoopState" />
<apidata name="ParallelLoopState" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="P:System.Threading.Tasks.ParallelLoopState.IsExceptional" />
<element api="P:System.Threading.Tasks.ParallelLoopState.IsStopped" />
<element api="P:System.Threading.Tasks.ParallelLoopState.LowestBreakIteration" />
<element api="P:System.Threading.Tasks.ParallelLoopState.ShouldExitCurrentIteration" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" />
</containers>
<file name="92d81b9b-5c14-4a80-2d91-f78c2030f56f" />
</api>
<api id="M:System.Threading.Tasks.ParallelLoopState.Break">
<topicdata group="api" />
<apidata name="Break" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="d5eefd41-74c7-e409-ceb8-97e084edfe67" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopState.IsExceptional">
<topicdata group="api" />
<apidata name="IsExceptional" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_IsExceptional" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="a836abf6-a182-dc00-00ee-a3ca68841525" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopState.IsStopped">
<topicdata group="api" />
<apidata name="IsStopped" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_IsStopped" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="ed1237e5-ef88-dbfe-a0f8-f88b73bf853c" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopState.LowestBreakIteration">
<topicdata group="api" />
<apidata name="LowestBreakIteration" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_LowestBreakIteration" />
<returns>
<type api="T:System.Nullable`1" ref="false">
<specialization>
<type api="T:System.Int64" ref="false" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="66fb2932-6811-6a67-3b73-e33026eac4e7" />
</api>
<api id="P:System.Threading.Tasks.ParallelLoopState.ShouldExitCurrentIteration">
<topicdata group="api" />
<apidata name="ShouldExitCurrentIteration" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_ShouldExitCurrentIteration" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="c17f7849-f2a3-9d14-cc6a-64d226939063" />
</api>
<api id="M:System.Threading.Tasks.ParallelLoopState.Stop">
<topicdata group="api" />
<apidata name="Stop" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelLoopState" ref="true" />
</containers>
<file name="d3c250a1-e932-9521-c97d-7b2d42a3a317" />
</api>
<api id="T:System.Threading.Tasks.ParallelOptions">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.ParallelOptions" />
<apidata name="ParallelOptions" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ParallelOptions.#ctor" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="b1c784a1-5dd9-7f47-797e-e639ac7df201" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.ParallelOptions">
<topicdata name="ParallelOptions" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.ParallelOptions" />
<apidata name="ParallelOptions" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ParallelOptions.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.ParallelOptions.#ctor" />
<element api="P:System.Threading.Tasks.ParallelOptions.CancellationToken" />
<element api="P:System.Threading.Tasks.ParallelOptions.MaxDegreeOfParallelism" />
<element api="P:System.Threading.Tasks.ParallelOptions.TaskScheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" />
</containers>
<file name="a24686f5-9bdd-3adf-1f96-b4569e890728" />
</api>
<api id="Methods.T:System.Threading.Tasks.ParallelOptions">
<topicdata name="ParallelOptions" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.ParallelOptions" />
<apidata name="ParallelOptions" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ParallelOptions.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" />
</containers>
<file name="02e20363-8153-12a2-713f-a41c195d81e0" />
</api>
<api id="Properties.T:System.Threading.Tasks.ParallelOptions">
<topicdata name="ParallelOptions" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.ParallelOptions" />
<apidata name="ParallelOptions" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.ParallelOptions.#ctor" />
<elements>
<element api="P:System.Threading.Tasks.ParallelOptions.CancellationToken" />
<element api="P:System.Threading.Tasks.ParallelOptions.MaxDegreeOfParallelism" />
<element api="P:System.Threading.Tasks.ParallelOptions.TaskScheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" />
</containers>
<file name="4931a48c-e0b4-3062-02e7-3b432c2a32e3" />
</api>
<api id="M:System.Threading.Tasks.ParallelOptions.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</containers>
<file name="678ed76e-2ba6-f40e-9ca8-8f45b16b909f" />
</api>
<api id="P:System.Threading.Tasks.ParallelOptions.CancellationToken">
<topicdata group="api" />
<apidata name="CancellationToken" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" set="true" />
<getter name="get_CancellationToken" />
<setter name="set_CancellationToken" />
<returns>
<type api="T:System.Threading.CancellationToken" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</containers>
<file name="11141aa2-9d0a-472c-d9ff-8d26f8eb2f8a" />
</api>
<api id="P:System.Threading.Tasks.ParallelOptions.MaxDegreeOfParallelism">
<topicdata group="api" />
<apidata name="MaxDegreeOfParallelism" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" set="true" />
<getter name="get_MaxDegreeOfParallelism" />
<setter name="set_MaxDegreeOfParallelism" />
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</containers>
<file name="09f0682f-64db-7dcb-6af8-666a8c4419f6" />
</api>
<api id="P:System.Threading.Tasks.ParallelOptions.TaskScheduler">
<topicdata group="api" />
<apidata name="TaskScheduler" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" set="true" />
<getter name="get_TaskScheduler" />
<setter name="set_TaskScheduler" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.ParallelOptions" ref="true" />
</containers>
<file name="8fd1f766-c337-7e1c-0d15-3526d7686aae" />
</api>
<api id="T:System.Threading.Tasks.Task">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
<descendents>
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</descendents>
</family>
<implements>
<type api="T:System.IAsyncResult" ref="true" />
<type api="T:System.IDisposable" ref="true" />
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="6e745a04-8cb4-a9ba-45c1-6526f37b957c" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.Task">
<topicdata name="Task" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.Task" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Windows.Threading.TaskExtensions.IsDispatcherOperationTask(System.Threading.Tasks.Task)" source="extension">
<apidata name="IsDispatcherOperationTask" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task,System.TimeSpan)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="Overload:System.Threading.Tasks.Task.#ctor">
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="P:System.Threading.Tasks.Task.AsyncState" />
<element api="P:System.Threading.Tasks.Task.CompletedTask" />
<element api="M:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean)" />
<element api="Overload:System.Threading.Tasks.Task.ContinueWith">
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.Task.CreationOptions" />
<element api="P:System.Threading.Tasks.Task.CurrentId" />
<element api="Overload:System.Threading.Tasks.Task.Delay">
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Dispose">
<element api="M:System.Threading.Tasks.Task.Dispose" />
<element api="M:System.Threading.Tasks.Task.Dispose(System.Boolean)" />
</element>
<element api="P:System.Threading.Tasks.Task.Exception" />
<element api="P:System.Threading.Tasks.Task.Factory" />
<element api="Overload:System.Threading.Tasks.Task.FromCanceled">
<element api="M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.FromException">
<element api="M:System.Threading.Tasks.Task.FromException(System.Exception)" />
<element api="M:System.Threading.Tasks.Task.FromException``1(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.Task.FromResult``1(``0)" />
<element api="M:System.Threading.Tasks.Task.GetAwaiter" />
<element api="P:System.Threading.Tasks.Task.Id" />
<element api="P:System.Threading.Tasks.Task.IsCanceled" />
<element api="P:System.Threading.Tasks.Task.IsCompleted" />
<element api="P:System.Threading.Tasks.Task.IsFaulted" />
<element api="Overload:System.Threading.Tasks.Task.Run">
<element api="M:System.Threading.Tasks.Task.Run(System.Action)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.RunSynchronously">
<element api="M:System.Threading.Tasks.Task.RunSynchronously" />
<element api="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Start">
<element api="M:System.Threading.Tasks.Task.Start" />
<element api="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.Task.Status" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#AsyncWaitHandle" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#CompletedSynchronously" />
<element api="Overload:System.Threading.Tasks.Task.Wait">
<element api="M:System.Threading.Tasks.Task.Wait" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WaitAll">
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WaitAny">
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WhenAll">
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WhenAny">
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])" />
</element>
<element api="M:System.Threading.Tasks.Task.Yield" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" />
</containers>
<file name="2f717215-a6ae-0490-f251-b59c52a6c038" />
</api>
<api id="Methods.T:System.Threading.Tasks.Task">
<topicdata name="Task" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.Task" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Windows.Threading.TaskExtensions.IsDispatcherOperationTask(System.Threading.Tasks.Task)" source="extension">
<apidata name="IsDispatcherOperationTask" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task,System.TimeSpan)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean)" />
<element api="Overload:System.Threading.Tasks.Task.ContinueWith">
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Delay">
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Dispose">
<element api="M:System.Threading.Tasks.Task.Dispose" />
<element api="M:System.Threading.Tasks.Task.Dispose(System.Boolean)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.FromCanceled">
<element api="M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.FromException">
<element api="M:System.Threading.Tasks.Task.FromException(System.Exception)" />
<element api="M:System.Threading.Tasks.Task.FromException``1(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.Task.FromResult``1(``0)" />
<element api="M:System.Threading.Tasks.Task.GetAwaiter" />
<element api="Overload:System.Threading.Tasks.Task.Run">
<element api="M:System.Threading.Tasks.Task.Run(System.Action)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.RunSynchronously">
<element api="M:System.Threading.Tasks.Task.RunSynchronously" />
<element api="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Start">
<element api="M:System.Threading.Tasks.Task.Start" />
<element api="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.Wait">
<element api="M:System.Threading.Tasks.Task.Wait" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WaitAll">
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WaitAny">
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WhenAll">
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])" />
</element>
<element api="Overload:System.Threading.Tasks.Task.WhenAny">
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])" />
</element>
<element api="M:System.Threading.Tasks.Task.Yield" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" />
</containers>
<file name="0be03327-07cb-f02d-bfb8-a5f526063aa8" />
</api>
<api id="Properties.T:System.Threading.Tasks.Task">
<topicdata name="Task" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.Task" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="P:System.Threading.Tasks.Task.AsyncState" />
<element api="P:System.Threading.Tasks.Task.CompletedTask" />
<element api="P:System.Threading.Tasks.Task.CreationOptions" />
<element api="P:System.Threading.Tasks.Task.CurrentId" />
<element api="P:System.Threading.Tasks.Task.Exception" />
<element api="P:System.Threading.Tasks.Task.Factory" />
<element api="P:System.Threading.Tasks.Task.Id" />
<element api="P:System.Threading.Tasks.Task.IsCanceled" />
<element api="P:System.Threading.Tasks.Task.IsCompleted" />
<element api="P:System.Threading.Tasks.Task.IsFaulted" />
<element api="P:System.Threading.Tasks.Task.Status" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#AsyncWaitHandle" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#CompletedSynchronously" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" />
</containers>
<file name="adcb144f-4920-fa93-4502-eda0d57befdf" />
</api>
<api id="Overload:System.Threading.Tasks.Task.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="56d306c9-2bcb-127f-1544-c61bdff03ef1" />
</api>
<api id="Overload:System.Threading.Tasks.Task.ContinueWith">
<topicdata name="ContinueWith" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="56581286-c5b2-6c4b-9ab6-087345252fd3" />
</api>
<api id="Overload:System.Threading.Tasks.Task.Delay">
<topicdata name="Delay" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Delay" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.Int32,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Delay(System.TimeSpan,System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="4d069bbc-9899-28d7-d530-3bfab61f91ed" />
</api>
<api id="Overload:System.Threading.Tasks.Task.Dispose">
<topicdata name="Dispose" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Dispose" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.Dispose" />
<element api="M:System.Threading.Tasks.Task.Dispose(System.Boolean)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="ae2a041a-9763-5784-5e55-2c80d1912c8c" />
</api>
<api id="Overload:System.Threading.Tasks.Task.FromCanceled">
<topicdata name="FromCanceled" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="FromCanceled" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="ebe9181e-f6e7-bb10-a94f-e7e41b6eb182" />
</api>
<api id="Overload:System.Threading.Tasks.Task.FromException">
<topicdata name="FromException" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="FromException" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.FromException(System.Exception)" />
<element api="M:System.Threading.Tasks.Task.FromException``1(System.Exception)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="aa7df888-0d89-17c6-2523-05758014a2d7" />
</api>
<api id="Overload:System.Threading.Tasks.Task.Run">
<topicdata name="Run" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Run" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.Run(System.Action)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.Task.Run(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e204f195-7cfa-3da9-71ee-3298da08baae" />
</api>
<api id="Overload:System.Threading.Tasks.Task.RunSynchronously">
<topicdata name="RunSynchronously" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="RunSynchronously" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.RunSynchronously" />
<element api="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="bdef4788-421d-618d-03b4-1b4342292410" />
</api>
<api id="Overload:System.Threading.Tasks.Task.Start">
<topicdata name="Start" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Start" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.Start" />
<element api="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="c5414ecc-3efe-f674-bdf3-5f10d7ab97ab" />
</api>
<api id="Overload:System.Threading.Tasks.Task.Wait">
<topicdata name="Wait" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="Wait" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.Wait" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="00f2bae3-994c-5672-9be5-a28646fadceb" />
</api>
<api id="Overload:System.Threading.Tasks.Task.WaitAll">
<topicdata name="WaitAll" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="WaitAll" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="49ba024a-c30c-1a3d-60b4-ac26de2ced11" />
</api>
<api id="Overload:System.Threading.Tasks.Task.WaitAny">
<topicdata name="WaitAny" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="WaitAny" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="12a1d330-6d3f-baf5-73bb-40b54a40a55c" />
</api>
<api id="Overload:System.Threading.Tasks.Task.WhenAll">
<topicdata name="WhenAll" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="WhenAll" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAll(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fb5ca398-fadb-87c1-b8be-7997587cbb62" />
</api>
<api id="Overload:System.Threading.Tasks.Task.WhenAny">
<topicdata name="WhenAny" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task" />
<apidata name="WhenAny" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task.WhenAny(System.Threading.Tasks.Task[])" />
<element api="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8e9d6b0b-308b-6c36-dd18-82f482998d10" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="447d3e5d-34df-183e-7167-0ba38b53b1b4" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="72d30da2-104d-153d-59f2-aa92e87773a1" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8a089a28-f35a-f596-280e-7a8d7b0038cd" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="43c30700-18db-c2a9-084b-70c70d61cc52" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="89e92f43-6eed-c287-333f-e1977ac45533" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="731d6a12-af98-4579-dc67-76381b9ba394" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="80c97908-c822-8049-0115-4ac52cac5a81" />
</api>
<api id="M:System.Threading.Tasks.Task.#ctor(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task.#ctor" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="17f3119f-8f51-0dc2-6b49-14ca326094d0" />
</api>
<api id="P:System.Threading.Tasks.Task.AsyncState">
<topicdata group="api" />
<apidata name="AsyncState" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="true" final="true" />
<propertydata get="true" />
<getter name="get_AsyncState" />
<returns>
<type api="T:System.Object" ref="true" />
</returns>
<implements>
<member api="P:System.IAsyncResult.AsyncState">
<type api="T:System.IAsyncResult" ref="true" />
</member>
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="af591191-6e25-bbd1-e8b2-adde8b3ee1e9" />
</api>
<api id="P:System.Threading.Tasks.Task.CompletedTask">
<topicdata group="api" />
<apidata name="CompletedTask" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CompletedTask" />
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e3c3f166-72e2-91f5-bb99-dcb7d7ac0841" />
</api>
<api id="M:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean)">
<topicdata group="api" />
<apidata name="ConfigureAwait" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continueOnCapturedContext">
<type api="T:System.Boolean" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f0b2a69c-ce12-8775-5947-20424dbdc9b8" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f92419e7-d194-54bb-235d-e41c7e9e9446" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8896d85a-2dbd-fcbc-ad30-f824babf61a1" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="5cba466b-90b7-7a52-6311-2497731a40e3" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fe13a991-4752-78e8-1276-235364d3890a" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="32a39525-111d-86d3-1fac-e87282bd0e51" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fbb7c527-cae5-18aa-073e-189e9ff32b98" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="812d8878-d984-378c-f884-7745c03ea7f5" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="153fd178-a9be-3878-fb42-8f96d38d94f0" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="0a38afc2-9e64-6f72-e263-306eee6dc59f" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="2c729379-29f3-71eb-807a-4c237c85ee11" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="60781fcf-d422-bd55-a40e-b7b4c11917a2" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f9774a7c-0ac0-d154-b660-0f6ccad1d7ae" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f9c2f880-cfbd-40b4-9183-81cda6194d4b" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f602595e-c33f-787a-d65d-3b3a7cab20cd" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8400c9b3-d5f9-bced-0a74-1962bede2115" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="7057d089-8476-031a-572d-37d9ac17e5ce" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="dae2da5f-8996-4ae9-d9c4-8dcc0a2b9176" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="b5741064-d2ad-c910-6c0c-7da3cd336c8b" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="b6382281-6e7d-5aa4-f44d-d5d8c63e6c11" />
</api>
<api id="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="d468eb62-600f-3ef8-aaa3-454eade3f022" />
</api>
<api id="P:System.Threading.Tasks.Task.CreationOptions">
<topicdata group="api" />
<apidata name="CreationOptions" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CreationOptions" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="401c8c69-b16f-eeb4-79d3-39bbdd90c677" />
</api>
<api id="P:System.Threading.Tasks.Task.CurrentId">
<topicdata group="api" />
<apidata name="CurrentId" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CurrentId" />
<returns>
<type api="T:System.Nullable`1" ref="false">
<specialization>
<type api="T:System.Int32" ref="false" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="c0c97907-48f5-6860-6ab1-928b6c257974" />
</api>
<api id="M:System.Threading.Tasks.Task.Delay(System.Int32)">
<topicdata group="api" />
<apidata name="Delay" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Delay" />
<proceduredata virtual="false" />
<parameters>
<parameter name="millisecondsDelay">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="a291b134-4343-6a4f-bb80-0df4a1f54a45" />
</api>
<api id="M:System.Threading.Tasks.Task.Delay(System.Int32,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Delay" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Delay" />
<proceduredata virtual="false" />
<parameters>
<parameter name="millisecondsDelay">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="9702b85f-82e0-d6b8-947b-19d16ff87923" />
</api>
<api id="M:System.Threading.Tasks.Task.Delay(System.TimeSpan)">
<topicdata group="api" />
<apidata name="Delay" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Delay" />
<proceduredata virtual="false" />
<parameters>
<parameter name="delay">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fb71a687-9b5b-8443-8c07-4d79b29c99cc" />
</api>
<api id="M:System.Threading.Tasks.Task.Delay(System.TimeSpan,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Delay" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Delay" />
<proceduredata virtual="false" />
<parameters>
<parameter name="delay">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="85ae70b0-d39d-b7f7-094d-8d1a551e9691" />
</api>
<api id="M:System.Threading.Tasks.Task.Dispose">
<topicdata group="api" />
<apidata name="Dispose" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Dispose" />
<proceduredata virtual="true" final="true" />
<implements>
<member api="M:System.IDisposable.Dispose">
<type api="T:System.IDisposable" ref="true" />
</member>
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="db75a69d-39a0-211f-5ef5-bbe3666f4cd2" />
</api>
<api id="M:System.Threading.Tasks.Task.Dispose(System.Boolean)">
<topicdata group="api" />
<apidata name="Dispose" group="member" subgroup="method" />
<memberdata visibility="family" overload="Overload:System.Threading.Tasks.Task.Dispose" />
<proceduredata virtual="true" />
<parameters>
<parameter name="disposing">
<type api="T:System.Boolean" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e732d429-1478-8d89-82f7-9739fdb9eb79" />
</api>
<api id="P:System.Threading.Tasks.Task.Exception">
<topicdata group="api" />
<apidata name="Exception" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Exception" />
<returns>
<type api="T:System.AggregateException" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3f78dc0b-d42c-9558-4a68-34fa6c0fdc61" />
</api>
<api id="P:System.Threading.Tasks.Task.Factory">
<topicdata group="api" />
<apidata name="Factory" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Factory" />
<returns>
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="02cb44bd-ef41-3a99-76a6-75e73bb2639d" />
</api>
<api id="M:System.Threading.Tasks.Task.FromCanceled(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="FromCanceled" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.FromCanceled" />
<proceduredata virtual="false" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fbe4c53d-5a14-2fc3-c6b5-9e3278c340ed" />
</api>
<api id="M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="FromCanceled" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.FromCanceled" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.FromCanceled``1(System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="bb251ec5-6e15-d551-5501-d47b01a533be" />
</api>
<api id="M:System.Threading.Tasks.Task.FromException(System.Exception)">
<topicdata group="api" />
<apidata name="FromException" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.FromException" />
<proceduredata virtual="false" />
<parameters>
<parameter name="exception">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3d1efe55-dbe0-2146-47d1-d1d60191ec94" />
</api>
<api id="M:System.Threading.Tasks.Task.FromException``1(System.Exception)">
<topicdata group="api" />
<apidata name="FromException" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.FromException" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="exception">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.FromException``1(System.Exception)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e5c51d23-ff96-d114-e983-20ccda12529b" />
</api>
<api id="M:System.Threading.Tasks.Task.FromResult``1(``0)">
<topicdata group="api" />
<apidata name="FromResult" group="member" subgroup="method" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="result">
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.FromResult``1(``0)" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.FromResult``1(``0)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e786a311-cad7-4ae6-66dc-a947c5a85e51" />
</api>
<api id="M:System.Threading.Tasks.Task.GetAwaiter">
<topicdata group="api" />
<apidata name="GetAwaiter" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Runtime.CompilerServices.TaskAwaiter" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="4fec6598-abb8-74ca-b7cd-d98c206b7b33" />
</api>
<api id="P:System.Threading.Tasks.Task.Id">
<topicdata group="api" />
<apidata name="Id" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Id" />
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="bc644878-c24d-af94-197a-8c241725b54c" />
</api>
<api id="P:System.Threading.Tasks.Task.IsCanceled">
<topicdata group="api" />
<apidata name="IsCanceled" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_IsCanceled" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="111ecd37-77bb-97b1-ad5d-602cd0a4b4cf" />
</api>
<api id="P:System.Threading.Tasks.Task.IsCompleted">
<topicdata group="api" />
<apidata name="IsCompleted" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="true" final="true" />
<propertydata get="true" />
<getter name="get_IsCompleted" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<implements>
<member api="P:System.IAsyncResult.IsCompleted">
<type api="T:System.IAsyncResult" ref="true" />
</member>
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="ab168a8d-bf86-8a7a-c1a3-24794f97fbee" />
</api>
<api id="P:System.Threading.Tasks.Task.IsFaulted">
<topicdata group="api" />
<apidata name="IsFaulted" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_IsFaulted" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="5c49c0e9-f44a-dfd4-30ce-560ab237e0db" />
</api>
<api id="M:System.Threading.Tasks.Task.Run(System.Action)">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f301fc89-88bb-d9ee-717f-17e776fb3c78" />
</api>
<api id="M:System.Threading.Tasks.Task.Run(System.Action,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3cc5aa5f-0b59-6f08-ee77-d96004675b9e" />
</api>
<api id="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="dfb70e2b-db73-16d7-ce6a-43bd886dfde6" />
</api>
<api id="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="9e659b3d-7918-f40b-410a-98b504137b98" />
</api>
<api id="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="57171f10-bffb-7525-86a1-6f55cb8eed01" />
</api>
<api id="M:System.Threading.Tasks.Task.Run(System.Func{System.Threading.Tasks.Task},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="d9b4b20f-2526-b999-ef47-de076f45db99" />
</api>
<api id="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="e4ffe0c3-f070-7b8b-65cc-1665927a9ebd" />
</api>
<api id="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Run" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.Run" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.Run``1(System.Func{``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="4c6274db-19e2-05c6-589a-9b988d5b8cc5" />
</api>
<api id="M:System.Threading.Tasks.Task.RunSynchronously">
<topicdata group="api" />
<apidata name="RunSynchronously" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.RunSynchronously" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8b3fea4a-07df-779c-314c-e34b824b2881" />
</api>
<api id="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="RunSynchronously" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.RunSynchronously" />
<proceduredata virtual="false" />
<parameters>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="05c578cb-a344-546f-edfd-698e874388c0" />
</api>
<api id="M:System.Threading.Tasks.Task.Start">
<topicdata group="api" />
<apidata name="Start" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Start" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="dc8731af-6368-8d25-1662-e77dfbe98b5f" />
</api>
<api id="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="Start" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Start" />
<proceduredata virtual="false" />
<parameters>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="238bf358-02f9-a458-4a3b-c5142eaefa41" />
</api>
<api id="P:System.Threading.Tasks.Task.Status">
<topicdata group="api" />
<apidata name="Status" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Status" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="393c1e77-4a53-7741-62f9-41ea0c957a26" />
</api>
<api id="P:System.Threading.Tasks.Task.System#IAsyncResult#AsyncWaitHandle">
<topicdata group="api" eiiName="IAsyncResult.AsyncWaitHandle" />
<apidata name="AsyncWaitHandle" group="member" subgroup="property" />
<memberdata visibility="private" />
<proceduredata virtual="true" final="true" eii="true" />
<propertydata get="true" />
<getter name="get_System.IAsyncResult.AsyncWaitHandle" />
<returns>
<type api="T:System.Threading.WaitHandle" ref="true" />
</returns>
<implements>
<member api="P:System.IAsyncResult.AsyncWaitHandle">
<type api="T:System.IAsyncResult" ref="true" />
</member>
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="1bc0a283-b49d-adbc-833c-acb419d4b58b" />
</api>
<api id="P:System.Threading.Tasks.Task.System#IAsyncResult#CompletedSynchronously">
<topicdata group="api" eiiName="IAsyncResult.CompletedSynchronously" />
<apidata name="CompletedSynchronously" group="member" subgroup="property" />
<memberdata visibility="private" />
<proceduredata virtual="true" final="true" eii="true" />
<propertydata get="true" />
<getter name="get_System.IAsyncResult.CompletedSynchronously" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<implements>
<member api="P:System.IAsyncResult.CompletedSynchronously">
<type api="T:System.IAsyncResult" ref="true" />
</member>
</implements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="a262654f-47dd-804b-d50a-85028eafd257" />
</api>
<api id="M:System.Threading.Tasks.Task.Wait">
<topicdata group="api" />
<apidata name="Wait" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Wait" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="199efe1b-4fe4-fa4c-627f-ed6a6792345a" />
</api>
<api id="M:System.Threading.Tasks.Task.Wait(System.Int32)">
<topicdata group="api" />
<apidata name="Wait" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Wait" />
<proceduredata virtual="false" />
<parameters>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="a877e7f8-286e-29b8-cff4-45fa988c7ce7" />
</api>
<api id="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Wait" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Wait" />
<proceduredata virtual="false" />
<parameters>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="ac279495-fa16-fa52-d2c7-709d6867e76b" />
</api>
<api id="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="Wait" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Wait" />
<proceduredata virtual="false" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="380d14d4-fdf7-0c1b-df10-8664797007f2" />
</api>
<api id="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)">
<topicdata group="api" />
<apidata name="Wait" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task.Wait" />
<proceduredata virtual="false" />
<parameters>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="03575685-a20b-782f-0cbb-d1356695a366" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[])">
<topicdata group="api" />
<apidata name="WaitAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="f45ca77c-c615-bf2d-2613-923bbe6bbfb3" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32)">
<topicdata group="api" />
<apidata name="WaitAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="9574922f-85c5-a787-68a6-6fa8b470a9a7" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="WaitAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="fab3b672-b35e-9556-a8ee-8313f2cc5d28" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="WaitAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="22579a69-d774-8a40-ede8-c68cb6e878df" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAll(System.Threading.Tasks.Task[],System.TimeSpan)">
<topicdata group="api" />
<apidata name="WaitAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="7d6609f7-1018-f8a6-c6e9-2e85f3c93e01" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[])">
<topicdata group="api" />
<apidata name="WaitAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
</parameters>
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="c8a4028d-6698-073f-7531-7a9d27f79b31" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32)">
<topicdata group="api" />
<apidata name="WaitAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3915bac6-8999-85b5-b42a-c89de6910884" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Int32,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="WaitAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="millisecondsTimeout">
<type api="T:System.Int32" ref="false" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8a726eba-698a-f9ba-945a-a844cea6fe4f" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="WaitAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3e6bc7e0-bebb-658d-f45e-6c9a9b0a5e67" />
</api>
<api id="M:System.Threading.Tasks.Task.WaitAny(System.Threading.Tasks.Task[],System.TimeSpan)">
<topicdata group="api" />
<apidata name="WaitAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WaitAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="2ef6bc75-ebcb-936e-65d9-c060f3ecc3cc" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})">
<topicdata group="api" />
<apidata name="WhenAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<arrayOf rank="1">
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAll``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
</arrayOf>
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="183fd4b6-e36d-67a8-ece8-ca08423ad5cc" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAll(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="WhenAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="6d1c3569-68a9-d1e5-1975-aa83fcaf4b17" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAll(System.Threading.Tasks.Task[])">
<topicdata group="api" />
<apidata name="WhenAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="3d1a9d92-d898-0199-1ac0-f20df4c0222d" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])">
<topicdata group="api" />
<apidata name="WhenAll" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])" />
</specialization>
</type>
</arrayOf>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<arrayOf rank="1">
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAll``1(System.Threading.Tasks.Task{``0}[])" />
</arrayOf>
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="a59a774a-bbad-9972-d309-8b77d4f466a4" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})">
<topicdata group="api" />
<apidata name="WhenAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAny``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="61edaad7-dd4b-a2e2-c51b-ded76aa90cbe" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAny(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="WhenAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="c65861f1-3587-f99d-4b01-ef13c0703eb1" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAny(System.Threading.Tasks.Task[])">
<topicdata group="api" />
<apidata name="WhenAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="33162976-772c-30a1-f5f5-f65f89a50a24" />
</api>
<api id="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])">
<topicdata group="api" />
<apidata name="WhenAny" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.Task.WhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks" params="true">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])" />
</specialization>
</type>
</arrayOf>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.Task.WhenAny``1(System.Threading.Tasks.Task{``0}[])" />
</specialization>
</type>
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="8edf2870-c43b-b0ea-bd6c-c9bc9951cd14" />
</api>
<api id="M:System.Threading.Tasks.Task.Yield">
<topicdata group="api" />
<apidata name="Yield" group="member" subgroup="method" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Runtime.CompilerServices.YieldAwaitable" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task" ref="true" />
</containers>
<file name="2d481f83-d81b-1f14-d54c-6c24a7617a95" />
</api>
<api id="T:System.Threading.Tasks.Task`1">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task`1" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<family>
<ancestors>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<templates>
<template name="TResult" />
</templates>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="7fb7a75c-f83d-c69f-11b3-68fd5c67c3cd" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.Task`1">
<topicdata name="Task" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.Task`1" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="P:System.Threading.Tasks.Task.AsyncState" />
<element api="Overload:System.Threading.Tasks.Task`1.ContinueWith">
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.Task.CreationOptions" />
<element api="Overload:System.Threading.Tasks.Task`1.Dispose">
<element api="M:System.Threading.Tasks.Task.Dispose" />
<element api="M:System.Threading.Tasks.Task.Dispose(System.Boolean)" />
</element>
<element api="P:System.Threading.Tasks.Task.Exception" />
<element api="P:System.Threading.Tasks.Task.Id" />
<element api="P:System.Threading.Tasks.Task.IsCanceled" />
<element api="P:System.Threading.Tasks.Task.IsCompleted" />
<element api="P:System.Threading.Tasks.Task.IsFaulted" />
<element api="Overload:System.Threading.Tasks.Task`1.RunSynchronously">
<element api="M:System.Threading.Tasks.Task.RunSynchronously" />
<element api="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task`1.Start">
<element api="M:System.Threading.Tasks.Task.Start" />
<element api="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.Task.Status" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#AsyncWaitHandle" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#CompletedSynchronously" />
<element api="Overload:System.Threading.Tasks.Task`1.Wait">
<element api="M:System.Threading.Tasks.Task.Wait" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="M:System.Windows.Threading.TaskExtensions.IsDispatcherOperationTask(System.Threading.Tasks.Task)" source="extension">
<apidata name="IsDispatcherOperationTask" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task,System.TimeSpan)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="Overload:System.Threading.Tasks.Task`1.#ctor">
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0})" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean)" />
<element api="P:System.Threading.Tasks.Task`1.Factory" />
<element api="M:System.Threading.Tasks.Task`1.GetAwaiter" />
<element api="P:System.Threading.Tasks.Task`1.Result" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" />
</containers>
<file name="9d94daf7-f16c-6f90-b00f-48321638e292" />
</api>
<api id="Methods.T:System.Threading.Tasks.Task`1">
<topicdata name="Task" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.Task`1" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.Task`1.ContinueWith">
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task`1.Dispose">
<element api="M:System.Threading.Tasks.Task.Dispose" />
<element api="M:System.Threading.Tasks.Task.Dispose(System.Boolean)" />
</element>
<element api="Overload:System.Threading.Tasks.Task`1.RunSynchronously">
<element api="M:System.Threading.Tasks.Task.RunSynchronously" />
<element api="M:System.Threading.Tasks.Task.RunSynchronously(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task`1.Start">
<element api="M:System.Threading.Tasks.Task.Start" />
<element api="M:System.Threading.Tasks.Task.Start(System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.Task`1.Wait">
<element api="M:System.Threading.Tasks.Task.Wait" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.TimeSpan)" />
<element api="M:System.Threading.Tasks.Task.Wait(System.Int32,System.Threading.CancellationToken)" />
</element>
<element api="M:System.Windows.Threading.TaskExtensions.IsDispatcherOperationTask(System.Threading.Tasks.Task)" source="extension">
<apidata name="IsDispatcherOperationTask" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Windows.Threading.TaskExtensions.DispatcherOperationWait(System.Threading.Tasks.Task,System.TimeSpan)" source="extension" overload="true">
<apidata name="DispatcherOperationWait" group="member" subgroup="method" subsubgroup="extension" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="timeout">
<type api="T:System.TimeSpan" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Windows.Threading.DispatcherOperationStatus" ref="false" />
</returns>
<containers>
<library assembly="System.Windows.Presentation" module="System.Windows.Presentation" kind="DynamicallyLinkedLibrary" />
<namespace api="N:System.Windows.Threading" />
<type api="T:System.Windows.Threading.TaskExtensions" ref="true" />
</containers>
</element>
<element api="M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean)" />
<element api="M:System.Threading.Tasks.Task`1.GetAwaiter" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" />
</containers>
<file name="77ac99f1-ed54-8810-a0ef-1675312f0320" />
</api>
<api id="Properties.T:System.Threading.Tasks.Task`1">
<topicdata name="Task" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.Task`1" />
<apidata name="Task" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="P:System.Threading.Tasks.Task.AsyncState" />
<element api="P:System.Threading.Tasks.Task.CreationOptions" />
<element api="P:System.Threading.Tasks.Task.Exception" />
<element api="P:System.Threading.Tasks.Task.Id" />
<element api="P:System.Threading.Tasks.Task.IsCanceled" />
<element api="P:System.Threading.Tasks.Task.IsCompleted" />
<element api="P:System.Threading.Tasks.Task.IsFaulted" />
<element api="P:System.Threading.Tasks.Task.Status" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#AsyncWaitHandle" />
<element api="P:System.Threading.Tasks.Task.System#IAsyncResult#CompletedSynchronously" />
<element api="P:System.Threading.Tasks.Task`1.Factory" />
<element api="P:System.Threading.Tasks.Task`1.Result" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" />
</containers>
<file name="f91e3f18-7ee1-3549-c575-4fd7edfb0211" />
</api>
<api id="Overload:System.Threading.Tasks.Task`1.ContinueWith">
<topicdata name="ContinueWith" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task`1" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith(System.Action{System.Threading.Tasks.Task,System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task.ContinueWith``1(System.Func{System.Threading.Tasks.Task,System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="1ee9c31e-d7c0-6780-8782-c2fd2c5a6c22" />
</api>
<api id="Overload:System.Threading.Tasks.Task`1.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.Task`1" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0})" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="be93a060-1748-2d9f-b9da-86d8400b9e5d" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0})">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="ad7bfb37-d084-21dc-b6d3-e251204802b5" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="6f642bb1-fa37-4d52-13f6-ec7a64b6add6" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="6329536d-2935-7e83-f86e-def871d71e9a" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="b13973e6-db6a-09df-7378-ca4b612bf9f3" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="f829467d-2a4a-7bff-66ca-97cdc3bf084b" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="89852872-eebb-f7f6-8fa2-07ff3812bce3" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="dc68d080-1a8f-1bcc-60fd-282bed353490" />
</api>
<api id="M:System.Threading.Tasks.Task`1.#ctor(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.Task`1.#ctor" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="db9f6423-4e7d-823d-adcb-fd0b2c5bdb02" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ConfigureAwait(System.Boolean)">
<topicdata group="api" />
<apidata name="ConfigureAwait" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continueOnCapturedContext">
<type api="T:System.Boolean" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1" ref="false">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="a875ef07-37fa-942c-0904-4e1266bb8418" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}})">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="b8bafe09-ca27-1231-d374-00725027e9cb" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="1966ecf0-7fec-516a-0715-838e14fa07b6" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="cd5e0d5e-a1e7-6a6d-6a07-fdbc7602f75a" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="2f4175c5-dc0d-f876-b99e-d833683c4862" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0}},System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="325cb0fa-9e04-748b-9da5-414af71db091" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="82fed7c9-a698-13fb-54a7-d1d6141fca00" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="eb1df562-5d27-a7db-9405-1a68542dad48" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="b64654ee-e243-e491-bf50-4ad7fba8915f" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="4d309b85-00be-e07c-22c5-d008eee7958d" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith(System.Action{System.Threading.Tasks.Task{`0},System.Object},System.Object,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<parameters>
<parameter name="continuationAction">
<type api="T:System.Action`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="ea685611-9e2e-4090-86c2-eb097ee80cb4" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="49245dc7-48d8-ec96-5be1-b6f2464bb652" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="25dc9e32-6dfe-7f1f-9699-ce398f72231a" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="718f826f-241c-7125-de94-af817c4c2c78" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="f66b5090-0951-b88a-8880-0d4889649c63" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},``0},System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="04e294a2-03da-7e17-655b-7bddce9d69a5" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="188a56f5-1fd2-68ff-d678-330c231b7221" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="54e1d3e3-0a8a-8ebf-e161-cd62e13ed9d7" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="7bb1d9fe-692c-a651-d543-6b00ce7f844b" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="7f20154b-0c90-7267-92a5-7239162474a0" />
</api>
<api id="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWith" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.Task`1.ContinueWith" />
<proceduredata virtual="false" />
<templates>
<template name="TNewResult" />
</templates>
<parameters>
<parameter name="continuationFunction">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
<type api="T:System.Object" ref="true" />
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TNewResult" index="0" api="M:System.Threading.Tasks.Task`1.ContinueWith``1(System.Func{System.Threading.Tasks.Task{`0},System.Object,``0},System.Object,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="a85eab9a-9d3b-8660-f5f4-d1c8bb1d1752" />
</api>
<api id="P:System.Threading.Tasks.Task`1.Factory">
<topicdata group="api" />
<apidata name="Factory" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Factory" />
<returns>
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="2d8885c9-047d-3c41-59ba-12d058469cfa" />
</api>
<api id="M:System.Threading.Tasks.Task`1.GetAwaiter">
<topicdata group="api" />
<apidata name="GetAwaiter" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Runtime.CompilerServices.TaskAwaiter`1" ref="false">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="f639d6e1-668b-5a71-6606-881f1a27c067" />
</api>
<api id="P:System.Threading.Tasks.Task`1.Result">
<topicdata group="api" />
<apidata name="Result" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Result" />
<returns>
<template name="TResult" index="0" api="T:System.Threading.Tasks.Task`1" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.Task`1" ref="true" />
</containers>
<file name="b0906682-249f-19e7-128e-711a6ac4b544" />
</api>
<api id="T:System.Threading.Tasks.TaskCanceledException">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCanceledException" />
<apidata name="TaskCanceledException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<family>
<ancestors>
<type api="T:System.OperationCanceledException" ref="true" />
<type api="T:System.SystemException" ref="true" />
<type api="T:System.Exception" ref="true" />
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="a3b7ed30-d218-fa21-af41-316bc3909503" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskCanceledException">
<topicdata name="TaskCanceledException" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskCanceledException" />
<apidata name="TaskCanceledException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<elements>
<element api="P:System.Exception.Data" />
<element api="M:System.Exception.GetBaseException" />
<element api="M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Exception.GetType" />
<element api="P:System.Exception.HelpLink" />
<element api="P:System.Exception.HResult" />
<element api="P:System.Exception.InnerException" />
<element api="P:System.Exception.Message" />
<element api="E:System.Exception.SerializeObjectState" />
<element api="P:System.Exception.Source" />
<element api="P:System.Exception.StackTrace" />
<element api="P:System.Exception.TargetSite" />
<element api="M:System.Exception.ToString" />
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.MemberwiseClone" />
<element api="P:System.OperationCanceledException.CancellationToken" />
<element api="Overload:System.Threading.Tasks.TaskCanceledException.#ctor">
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception)" />
</element>
<element api="P:System.Threading.Tasks.TaskCanceledException.Task" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" />
</containers>
<file name="ea12ddb6-3937-dff9-70d4-d274b755f0f5" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskCanceledException">
<topicdata name="TaskCanceledException" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskCanceledException" />
<apidata name="TaskCanceledException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<elements>
<element api="M:System.Exception.GetBaseException" />
<element api="M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Exception.GetType" />
<element api="M:System.Exception.ToString" />
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.MemberwiseClone" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" />
</containers>
<file name="fa5c2ecc-5694-5c1f-caa4-4f57ca4a131a" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskCanceledException">
<topicdata name="TaskCanceledException" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskCanceledException" />
<apidata name="TaskCanceledException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<elements>
<element api="P:System.Exception.Data" />
<element api="P:System.Exception.HelpLink" />
<element api="P:System.Exception.HResult" />
<element api="P:System.Exception.InnerException" />
<element api="P:System.Exception.Message" />
<element api="P:System.Exception.Source" />
<element api="P:System.Exception.StackTrace" />
<element api="P:System.Exception.TargetSite" />
<element api="P:System.OperationCanceledException.CancellationToken" />
<element api="P:System.Threading.Tasks.TaskCanceledException.Task" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" />
</containers>
<file name="97a94e6b-4be3-1abd-576d-45d11f67c19e" />
</api>
<api id="Events.T:System.Threading.Tasks.TaskCanceledException">
<topicdata name="TaskCanceledException" group="list" subgroup="Events" typeTopicId="T:System.Threading.Tasks.TaskCanceledException" />
<apidata name="TaskCanceledException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<elements>
<element api="E:System.Exception.SerializeObjectState" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" />
</containers>
<file name="92b34cc8-e28f-8a61-3a71-e8908b08cbd1" />
</api>
<api id="Overload:System.Threading.Tasks.TaskCanceledException.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCanceledException" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="c37c71fe-c60c-3a30-fb61-7f450ea3b234" />
</api>
<api id="M:System.Threading.Tasks.TaskCanceledException.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCanceledException.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="7d486298-f4f0-7164-c092-071f7c0d0f63" />
</api>
<api id="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="family" special="true" overload="Overload:System.Threading.Tasks.TaskCanceledException.#ctor" />
<parameters>
<parameter name="info">
<type api="T:System.Runtime.Serialization.SerializationInfo" ref="true" />
</parameter>
<parameter name="context">
<type api="T:System.Runtime.Serialization.StreamingContext" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="6ad0555e-d774-a3fe-9b5c-93e4ebaf7542" />
</api>
<api id="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCanceledException.#ctor" />
<parameters>
<parameter name="message">
<type api="T:System.String" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="d40a11c6-ba66-703e-2976-0f7f4fd71604" />
</api>
<api id="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.String,System.Exception)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCanceledException.#ctor" />
<parameters>
<parameter name="message">
<type api="T:System.String" ref="true" />
</parameter>
<parameter name="innerException">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="a40b35d6-40d6-f282-9443-12cbf9a980a0" />
</api>
<api id="M:System.Threading.Tasks.TaskCanceledException.#ctor(System.Threading.Tasks.Task)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCanceledException.#ctor" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="a0334a26-4a7c-4bda-1869-632107903104" />
</api>
<api id="P:System.Threading.Tasks.TaskCanceledException.Task">
<topicdata group="api" />
<apidata name="Task" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Task" />
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCanceledException" ref="true" />
</containers>
<file name="7ca36fd1-24b5-df18-29d0-baba5986ca15" />
</api>
<api id="T:System.Threading.Tasks.TaskCompletionSource`1">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TaskCompletionSource" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<templates>
<template name="TResult" />
</templates>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="0404bf94-6b7d-25d3-03a2-de055059628c" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1">
<topicdata name="TaskCompletionSource" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TaskCompletionSource" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object)" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled" />
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.SetException">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0)" />
<element api="P:System.Threading.Tasks.TaskCompletionSource`1.Task" />
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetException">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</containers>
<file name="c7354b74-1da1-76c1-78ae-08011e65fe42" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskCompletionSource`1">
<topicdata name="TaskCompletionSource" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TaskCompletionSource" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled" />
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.SetException">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0)" />
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetException">
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception)" />
</element>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</containers>
<file name="a485effa-9581-7d1f-33f9-e83868ebdaf8" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskCompletionSource`1">
<topicdata name="TaskCompletionSource" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TaskCompletionSource" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="P:System.Threading.Tasks.TaskCompletionSource`1.Task" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</containers>
<file name="02792dd7-5302-1115-a198-1068f9201742" />
</api>
<api id="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object)" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="eeb5eeb0-c604-fffe-a280-d86e566fc746" />
</api>
<api id="Overload:System.Threading.Tasks.TaskCompletionSource`1.SetException">
<topicdata name="SetException" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="SetException" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="48a0ff21-fcfe-1e40-6f2e-25d3ff7d0234" />
</api>
<api id="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled">
<topicdata name="TrySetCanceled" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TrySetCanceled" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="3f729dae-9152-0c3a-d7ab-03da3c904c35" />
</api>
<api id="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetException">
<topicdata name="TrySetException" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskCompletionSource`1" />
<apidata name="TrySetException" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception})" />
<element api="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="96e97d70-4ea2-c980-884f-843902fa4796" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="c86c2666-0f62-f566-4b68-08afcc293f3d" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<parameters>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="17d41e9f-95a2-47c1-a89a-27346dc4fb4f" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<parameters>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="f86eb2f4-c00a-0fc7-ca17-5b8474c24d0c" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.#ctor(System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.#ctor" />
<parameters>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="63df5eae-fcd3-3068-f116-db7a1c3f3af9" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.SetCanceled">
<topicdata group="api" />
<apidata name="SetCanceled" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="8862dd32-d7ab-1fef-edea-be7d48669e29" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Collections.Generic.IEnumerable{System.Exception})">
<topicdata group="api" />
<apidata name="SetException" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.SetException" />
<proceduredata virtual="false" />
<parameters>
<parameter name="exceptions">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Exception" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="e84e97db-2c43-6d3d-0c2b-09b69a79cc6b" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.SetException(System.Exception)">
<topicdata group="api" />
<apidata name="SetException" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.SetException" />
<proceduredata virtual="false" />
<parameters>
<parameter name="exception">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="9f0a64a8-546d-bd33-b9e0-c9c6935c3bce" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.SetResult(`0)">
<topicdata group="api" />
<apidata name="SetResult" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="result">
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="dc0d0e81-51b0-f11f-31eb-4fb267ffb10b" />
</api>
<api id="P:System.Threading.Tasks.TaskCompletionSource`1.Task">
<topicdata group="api" />
<apidata name="Task" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Task" />
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="7638fe14-a4fb-7a60-451b-d9a8104b1646" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled">
<topicdata group="api" />
<apidata name="TrySetCanceled" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="e8d0d12a-e66f-8dc9-660b-490105466e2e" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="TrySetCanceled" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetCanceled" />
<proceduredata virtual="false" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="53f925b0-a1e3-aa3d-9ba9-d2696fb996bd" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Collections.Generic.IEnumerable{System.Exception})">
<topicdata group="api" />
<apidata name="TrySetException" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetException" />
<proceduredata virtual="false" />
<parameters>
<parameter name="exceptions">
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Exception" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="9e5ea84d-e537-0b9e-0a5a-b9be82e989a5" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetException(System.Exception)">
<topicdata group="api" />
<apidata name="TrySetException" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskCompletionSource`1.TrySetException" />
<proceduredata virtual="false" />
<parameters>
<parameter name="exception">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="e2aa20b7-2245-7225-14a9-0282210f9965" />
</api>
<api id="M:System.Threading.Tasks.TaskCompletionSource`1.TrySetResult(`0)">
<topicdata group="api" />
<apidata name="TrySetResult" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<parameters>
<parameter name="result">
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskCompletionSource`1" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCompletionSource`1" ref="true" />
</containers>
<file name="09448ef5-6130-f67b-a414-d69f116ddd6b" />
</api>
<api id="T:System.Threading.Tasks.TaskContinuationOptions">
<topicdata group="api" />
<apidata name="TaskContinuationOptions" group="type" subgroup="enumeration" />
<typedata visibility="public" sealed="true" serializable="true" />
<elements>
<element api="F:System.Threading.Tasks.TaskContinuationOptions.None" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.PreferFairness" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.LongRunning" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.AttachedToParent" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.DenyChildAttach" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.HideScheduler" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.LazyCancellation" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.RunContinuationsAsynchronously" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.NotOnRanToCompletion" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.NotOnFaulted" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.NotOnCanceled" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnRanToCompletion" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnCanceled" />
<element api="F:System.Threading.Tasks.TaskContinuationOptions.ExecuteSynchronously" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.FlagsAttribute" ref="true" />
</attribute>
</attributes>
<file name="cb3930a1-ef7b-52ff-d1bf-2b1c2c05f98f" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.AttachedToParent">
<topicdata group="api" notopic="" />
<apidata name="AttachedToParent" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>4</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="136bc0e8-aeff-7da8-7c4f-91035d2f7777" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.DenyChildAttach">
<topicdata group="api" notopic="" />
<apidata name="DenyChildAttach" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>8</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="94652dcb-9229-220b-ccd1-65728b45c811" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.ExecuteSynchronously">
<topicdata group="api" notopic="" />
<apidata name="ExecuteSynchronously" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>524288</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="4c0cd82d-65f8-ce1f-3a85-678946082327" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.HideScheduler">
<topicdata group="api" notopic="" />
<apidata name="HideScheduler" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>16</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="1bbbf134-aa74-53cd-c082-a25d7229072b" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.LazyCancellation">
<topicdata group="api" notopic="" />
<apidata name="LazyCancellation" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>32</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="7b2d885a-3f85-3842-011a-020683120312" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.LongRunning">
<topicdata group="api" notopic="" />
<apidata name="LongRunning" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>2</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="9dc2b95e-8924-9b05-95fb-6cb6cfe01748" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.None">
<topicdata group="api" notopic="" />
<apidata name="None" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>0</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="3d2faaa3-6ae7-ee3d-6986-18f9c66b29e7" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.NotOnCanceled">
<topicdata group="api" notopic="" />
<apidata name="NotOnCanceled" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>262144</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="5f4e9f59-1e66-f052-0c59-1184241a629f" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.NotOnFaulted">
<topicdata group="api" notopic="" />
<apidata name="NotOnFaulted" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>131072</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="47b09a6d-9892-33df-1348-ced06e2bc97e" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.NotOnRanToCompletion">
<topicdata group="api" notopic="" />
<apidata name="NotOnRanToCompletion" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>65536</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="425a0ee8-3f64-4a9a-8399-49af4ed6ccb1" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnCanceled">
<topicdata group="api" notopic="" />
<apidata name="OnlyOnCanceled" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>196608</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="1cb6d77b-845c-5e1b-8a5a-36519a1b4bc6" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnFaulted">
<topicdata group="api" notopic="" />
<apidata name="OnlyOnFaulted" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>327680</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="cdde1ac0-a879-67e2-df18-d59df52993b0" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.OnlyOnRanToCompletion">
<topicdata group="api" notopic="" />
<apidata name="OnlyOnRanToCompletion" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>393216</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="77f83203-53a2-9502-ff12-233fbb7fa02f" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.PreferFairness">
<topicdata group="api" notopic="" />
<apidata name="PreferFairness" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>1</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="ff461fdf-11c4-a4e0-5b8a-1470899b88cf" />
</api>
<api id="F:System.Threading.Tasks.TaskContinuationOptions.RunContinuationsAsynchronously">
<topicdata group="api" notopic="" />
<apidata name="RunContinuationsAsynchronously" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<value>64</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</containers>
<file name="c8bc0fef-4b20-c356-3507-3f54d38b70ff" />
</api>
<api id="T:System.Threading.Tasks.TaskCreationOptions">
<topicdata group="api" />
<apidata name="TaskCreationOptions" group="type" subgroup="enumeration" />
<typedata visibility="public" sealed="true" serializable="true" />
<elements>
<element api="F:System.Threading.Tasks.TaskCreationOptions.None" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.PreferFairness" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.LongRunning" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.AttachedToParent" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.DenyChildAttach" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.HideScheduler" />
<element api="F:System.Threading.Tasks.TaskCreationOptions.RunContinuationsAsynchronously" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.FlagsAttribute" ref="true" />
</attribute>
</attributes>
<file name="177eb117-14ae-b068-4d89-9ef4953379e1" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.AttachedToParent">
<topicdata group="api" notopic="" />
<apidata name="AttachedToParent" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>4</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="da14187c-e09b-8ee2-9e3a-7183726e02ee" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.DenyChildAttach">
<topicdata group="api" notopic="" />
<apidata name="DenyChildAttach" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>8</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="00db1ce8-71c5-862f-5bac-9c574d7dcc1b" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.HideScheduler">
<topicdata group="api" notopic="" />
<apidata name="HideScheduler" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>16</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="32c67c98-a337-80ad-46af-53c49f7c7bad" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.LongRunning">
<topicdata group="api" notopic="" />
<apidata name="LongRunning" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>2</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="cbe68fa3-53c4-0a34-3604-10a7be573024" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.None">
<topicdata group="api" notopic="" />
<apidata name="None" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>0</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="a04772dc-229b-40ff-e507-a9060af2f18e" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.PreferFairness">
<topicdata group="api" notopic="" />
<apidata name="PreferFairness" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>1</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="454b6ae8-5cb0-f889-bb3b-4f33d959def1" />
</api>
<api id="F:System.Threading.Tasks.TaskCreationOptions.RunContinuationsAsynchronously">
<topicdata group="api" notopic="" />
<apidata name="RunContinuationsAsynchronously" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<value>64</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</containers>
<file name="b9a04b8a-2bea-f826-0a6f-1f49e4b80212" />
</api>
<api id="T:System.Threading.Tasks.TaskExtensions">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskExtensions" />
<apidata name="TaskExtensions" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Runtime.CompilerServices.ExtensionAttribute" ref="true" />
</attribute>
</attributes>
<file name="bb0c580c-8e6f-928d-20ee-297fd209221f" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskExtensions">
<topicdata name="TaskExtensions" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskExtensions" />
<apidata name="TaskExtensions" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<elements>
<element api="Overload:System.Threading.Tasks.TaskExtensions.Unwrap">
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task})" />
</element>
</elements>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskExtensions" />
</containers>
<file name="aec3fb58-9c6c-e12a-86a0-9bb859c9e7c9" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskExtensions">
<topicdata name="TaskExtensions" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskExtensions" />
<apidata name="TaskExtensions" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" sealed="true" serializable="false" />
<elements>
<element api="Overload:System.Threading.Tasks.TaskExtensions.Unwrap">
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task})" />
</element>
</elements>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskExtensions" />
</containers>
<file name="4ac63f30-05cf-9f3f-644b-805ffbd8f3c5" />
</api>
<api id="Overload:System.Threading.Tasks.TaskExtensions.Unwrap">
<topicdata name="Unwrap" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskExtensions" />
<apidata name="Unwrap" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task})" />
</elements>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskExtensions" ref="true" />
</containers>
<file name="4a736d11-168a-1ed5-3ae0-0c9d1b0331d2" />
</api>
<api id="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})">
<topicdata group="api" />
<apidata name="Unwrap" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.TaskExtensions.Unwrap" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskExtensions.Unwrap``1(System.Threading.Tasks.Task{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskExtensions" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Runtime.CompilerServices.ExtensionAttribute" ref="true" />
</attribute>
</attributes>
<file name="9accf7e4-c2f0-0123-7873-573ddc5c390a" />
</api>
<api id="M:System.Threading.Tasks.TaskExtensions.Unwrap(System.Threading.Tasks.Task{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="Unwrap" group="member" subgroup="method" />
<memberdata visibility="public" static="true" overload="Overload:System.Threading.Tasks.TaskExtensions.Unwrap" />
<proceduredata virtual="false" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="System.Core" module="System.Core" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskExtensions" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Runtime.CompilerServices.ExtensionAttribute" ref="true" />
</attribute>
</attributes>
<file name="960105d9-eca8-d097-af8f-f4d2ff828ad4" />
</api>
<api id="T:System.Threading.Tasks.TaskFactory">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory.#ctor" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="5c940a30-d282-d996-6e6d-aa8cb9bced36" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskFactory">
<topicdata name="TaskFactory" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskFactory" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.TaskFactory.#ctor">
<element api="M:System.Threading.Tasks.TaskFactory.#ctor" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory.CancellationToken" />
<element api="P:System.Threading.Tasks.TaskFactory.ContinuationOptions" />
<element api="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll">
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny">
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory.CreationOptions" />
<element api="Overload:System.Threading.Tasks.TaskFactory.FromAsync">
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory.Scheduler" />
<element api="Overload:System.Threading.Tasks.TaskFactory.StartNew">
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" />
</containers>
<file name="8fd567e1-becd-e1e8-d76c-e1c5935bfce9" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskFactory">
<topicdata name="TaskFactory" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskFactory" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory.#ctor" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll">
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny">
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory.FromAsync">
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory.StartNew">
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" />
</containers>
<file name="c218f9af-7fec-d6f1-1489-a52469c96a7a" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskFactory">
<topicdata name="TaskFactory" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskFactory" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory.#ctor" />
<elements>
<element api="P:System.Threading.Tasks.TaskFactory.CancellationToken" />
<element api="P:System.Threading.Tasks.TaskFactory.ContinuationOptions" />
<element api="P:System.Threading.Tasks.TaskFactory.CreationOptions" />
<element api="P:System.Threading.Tasks.TaskFactory.Scheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" />
</containers>
<file name="248fb313-9955-524b-a995-aa652f514cc0" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory.#ctor" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="2e375a66-475a-5ee7-8739-699545f3ceef" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll">
<topicdata name="ContinueWhenAll" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="0d9e92e5-b03c-e489-5b24-88202f1598a0" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny">
<topicdata name="ContinueWhenAny" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="c59297f5-5535-8ca9-2bf2-8f02d7612f3b" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory.FromAsync">
<topicdata name="FromAsync" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name="FromAsync" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="e1cf8876-c25d-09d7-e86e-e0db8b884c35" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory.StartNew">
<topicdata name="StartNew" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory" />
<apidata name="StartNew" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="7d927859-8867-2540-f4dd-bd514f22c657" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="860c410a-e38e-9209-b977-4e8c0c7b40d9" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory.#ctor" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="bef7c484-1ff7-25ee-24fa-2c85ae21a885" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory.#ctor" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="882c23ec-9404-5889-812e-a7b8616b0cf3" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory.#ctor" />
<parameters>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="7ca1a2bd-8abf-47d4-08a7-1be3057c33a2" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.#ctor(System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory.#ctor" />
<parameters>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="6a2d6c0d-7baa-5749-ce04-8d26534aa0dd" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory.CancellationToken">
<topicdata group="api" />
<apidata name="CancellationToken" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CancellationToken" />
<returns>
<type api="T:System.Threading.CancellationToken" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="9b9460f4-ec23-bfdc-6d75-0e1f9a5a3f6a" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory.ContinuationOptions">
<topicdata group="api" />
<apidata name="ContinuationOptions" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_ContinuationOptions" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="3fa4d42e-6fc2-7b58-b1eb-0c3000bf2673" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="b7faed59-7737-42f2-59ae-96b1e62a9eae" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="52f12292-846f-a06a-543b-23b8d2b2f79e" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="4545fbff-d9b7-8607-2f44-3dd8fd8b3843" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task[]},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="c94b5050-205f-eb40-8eda-1b19932b8038" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="9e6fdff0-311f-a264-d322-5bf15a5716f2" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="b0c99928-d9ba-e0c3-9a8b-f794d1484e03" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="e9679c24-2b39-78f1-25a6-7f7c3a417950" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="cf7dedbd-5741-c3bb-a1b5-d8e85cdee0a6" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]})" />
</specialization>
</type>
</arrayOf>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="1a9667ac-6aa3-b0ec-0d4f-0fa0b00aa945" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="5c176e0d-e0aa-6737-ddcc-0a3fa2704900" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="562f8974-99c1-08eb-23fb-e40967268a9f" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}[]},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="8b3c5b07-4f70-4101-4b87-aac632354b43" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="1bd621b9-56d6-37c5-1ece-2bdcc8af1f08" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a7fc1194-154f-891a-e661-00ee28dd661b" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="7397f733-c966-0789-02df-2124e1abccde" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="ff04879a-1fc5-2829-ca26-ee30262f45fa" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="cc4fe6e9-29bc-f0d0-ceee-a597faf466fd" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a003ab5b-54ad-1e5a-ab11-edbdb4c314fd" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="340bfbf2-b36a-29a3-defe-b1a83882440c" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny(System.Threading.Tasks.Task[],System.Action{System.Threading.Tasks.Task},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="6d5881f0-642c-1793-6f28-29e209db1aa1" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="300d137f-c536-c1db-5b50-1de56f7fb0b0" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="9d6bd37b-720d-d8ff-bebd-6dc1afe9e9e0" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="31ee7c1d-5dc6-0029-507f-1c2608cda9a4" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,``0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="200c3603-bdcd-c09e-98db-ff971cc83168" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}})" />
</specialization>
</type>
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="90f196a3-7782-c180-5814-63eafc9cc5c5" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken)" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="341e07d2-1fc8-92f1-676d-f86d7cc31946" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="d70459bf-c76c-b324-b08f-3e4dbff3b096" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationAction">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Action{System.Threading.Tasks.Task{``0}},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="f9fc92f8-30e3-224a-6409-3af8c43caf98" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
</specialization>
</type>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="c549e454-a031-5a4f-7a4a-34f9045cf662" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
</specialization>
</type>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="dc3b43d2-af0a-0f6a-f785-e62d7318f214" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="beef76fd-78d0-f1f9-7ed4-35aecea4492b" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.ContinueWhenAny``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},``1},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="496f7b22-0ce4-cf2d-be7e-8e7195f946dd" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory.CreationOptions">
<topicdata group="api" />
<apidata name="CreationOptions" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CreationOptions" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="98be52b3-63e2-63f4-f388-0f6c511082b4" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="830341c2-6969-34a9-480a-a14ba793faf4" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="496aca76-09d4-ded1-807a-015b0dbd1635" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="5599fc81-5914-c216-bc3d-a4a0624aa8ad" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="27a3af28-38c5-ee1d-814b-23968e28e49c" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a2b29bb9-63ed-f3d0-095d-d0549c89fa37" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="9154986a-faa8-7740-5b5e-cb2752ce3ce5" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="350d7233-1535-c160-6326-b0e0603407d6" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``1},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="9f52566d-e38c-5eb3-d516-5625fa0cbbff" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="0acaf0ba-16f2-2ac6-3fb8-ff1674bbaa1e" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="ef12202b-2f80-e082-9b07-f505d68fcedd" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="56efe9c0-17da-7670-2b80-95fea4e62fdb" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``2},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="1406c84d-0358-23f8-3cc3-0acbc61259d6" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="603a8431-50ee-568d-c7c8-45e3c3759e38" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Action{System.IAsyncResult},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="51c400f3-3e73-ebcd-0447-f86e34ab7827" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="3" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="3" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="8a6cf849-2da1-8ffc-26a0-a3b78f7aee99" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
<template name="TResult" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="3" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="3" api="M:System.Threading.Tasks.TaskFactory.FromAsync``4(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,``3},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="cff5f502-c25a-44ab-03f2-530218b954ab" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult})">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="b0b1972b-2331-0c4f-63ff-72c5b685c4be" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="93a2a6b8-65a1-074f-13ab-28b3cfc24081" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync(System.IAsyncResult,System.Action{System.IAsyncResult},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="4f7fc6ff-ac29-4d10-c487-81c613c3974b" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="85fdeaa0-e774-7b65-b32a-cd4052c42a7e" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a6388a73-cf5e-5448-04fa-4236e1b2f75d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.FromAsync``1(System.IAsyncResult,System.Func{System.IAsyncResult,``0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="6bfe3c03-1eea-369a-8860-fce90eec079e" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory.Scheduler">
<topicdata group="api" />
<apidata name="Scheduler" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Scheduler" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="ed3a1a3e-61d5-997f-612d-d3ddb6132d1b" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="94456efb-931d-2916-c76a-3ffefc764b6f" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="100504a4-8bd7-49ba-499e-fb421189daa9" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="1a531a09-b3d8-b65b-3c26-c4dbaaf7d72b" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="11c1b4c4-fe54-b7e6-8b52-b53389d76a56" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a9e95762-7814-6b0f-abf5-a4c86b784a51" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="0077c920-aeb3-a0dc-cfb2-aff5462fc021" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="18fc4584-46ea-537b-556c-b3470a1f0c3d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew(System.Action{System.Object},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="action">
<type api="T:System.Action`1" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="f62c2521-c64e-46be-753f-7eaef62f0f3d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0})" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="a9d66907-94fd-66f3-bf47-2f2e8d0fd8f3" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="dba17393-009d-610a-3844-80dca204db7d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="32c007d1-fc04-e134-3281-c619ef7dc12d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{``0},System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="5602c25d-1ed3-c852-0b27-96040243d5f9" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="596e7cbe-210d-d5d8-6d04-0d028c5fe708" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="436791e7-e67b-0abe-2f53-a631a2529e10" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="28933cc3-fb38-8e06-eb06-e090e0cb672e" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory.StartNew" />
<proceduredata virtual="false" />
<templates>
<template name="TResult" />
</templates>
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="M:System.Threading.Tasks.TaskFactory.StartNew``1(System.Func{System.Object,``0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory" ref="true" />
</containers>
<file name="341044ad-7899-9182-2a73-05ad7ace4075" />
</api>
<api id="T:System.Threading.Tasks.TaskFactory`1">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<templates>
<template name="TResult" />
</templates>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="1046aefe-4fbd-a424-5dc1-075f4a259189" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskFactory`1">
<topicdata name="TaskFactory" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.TaskFactory`1.#ctor">
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory`1.CancellationToken" />
<element api="P:System.Threading.Tasks.TaskFactory`1.ContinuationOptions" />
<element api="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll">
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny">
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory`1.CreationOptions" />
<element api="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync">
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="P:System.Threading.Tasks.TaskFactory`1.Scheduler" />
<element api="Overload:System.Threading.Tasks.TaskFactory`1.StartNew">
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" />
</containers>
<file name="b030fe9c-200b-cafd-6796-8870116e8607" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskFactory`1">
<topicdata name="TaskFactory" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll">
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny">
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync">
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</element>
<element api="Overload:System.Threading.Tasks.TaskFactory`1.StartNew">
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" />
</containers>
<file name="b040347a-dc3a-ac17-8324-031b906b0de4" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskFactory`1">
<topicdata name="TaskFactory" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="TaskFactory" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" defaultConstructor="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<templates>
<template name="TResult" />
</templates>
<elements>
<element api="P:System.Threading.Tasks.TaskFactory`1.CancellationToken" />
<element api="P:System.Threading.Tasks.TaskFactory`1.ContinuationOptions" />
<element api="P:System.Threading.Tasks.TaskFactory`1.CreationOptions" />
<element api="P:System.Threading.Tasks.TaskFactory`1.Scheduler" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" />
</containers>
<file name="4a0b86f4-871e-dceb-2217-8418890b86a9" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory`1.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="fb5f17fa-2d6e-4a20-6d4c-d5302a9782a8" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll">
<topicdata name="ContinueWhenAll" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="ef10305b-198a-c784-f55d-bbb8bcd061d9" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny">
<topicdata name="ContinueWhenAny" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="6eb91f6e-d490-888b-c806-fee63f8b31cd" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync">
<topicdata name="FromAsync" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="FromAsync" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="b3daae9b-306e-bc9c-f35c-fc3cdda23bf4" />
</api>
<api id="Overload:System.Threading.Tasks.TaskFactory`1.StartNew">
<topicdata name="StartNew" group="list" subgroup="overload" memberSubgroup="method" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskFactory`1" />
<apidata name="StartNew" group="member" subgroup="method" />
<elements>
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0})" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
<element api="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="8b2db2ec-4433-cbd8-c42d-a505926c1820" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory`1.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="cb049830-4627-c591-4992-6b2d9758cd38" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory`1.#ctor" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="fffabfa3-5e38-da92-04ec-537797912637" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory`1.#ctor" />
<parameters>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="159628e1-dbac-793f-d32a-21de8b0db20d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory`1.#ctor" />
<parameters>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="2ed1feb9-6ef4-2386-0705-ebf2f51e66da" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.#ctor(System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskFactory`1.#ctor" />
<parameters>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="7f812fac-773a-0fd7-d06e-60ac410a0505" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory`1.CancellationToken">
<topicdata group="api" />
<apidata name="CancellationToken" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CancellationToken" />
<returns>
<type api="T:System.Threading.CancellationToken" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="1759d1ba-926c-ad91-ceba-46cdbafe1917" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory`1.ContinuationOptions">
<topicdata group="api" />
<apidata name="ContinuationOptions" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_ContinuationOptions" />
<returns>
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="336145ad-0582-68b0-9852-b67bc16a9025" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="b67554af-93e5-3965-3584-045d42c9a746" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="038d7932-77f3-3c10-d670-086b8dd97be2" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="9e277052-68f5-8837-fd6a-4a59d0a9fb22" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task[],`0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="14a9fd7c-c236-4c42-8da6-9b823f844b8e" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0})" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="89869fa4-2686-c50e-e38e-62613047e87f" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="d7eee5d6-4d45-d8d8-d105-c7cee7771a41" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="b4309330-5c2a-6188-e0cf-c217fbf36b88" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAll" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAll``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],`0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="aa276c9e-3e8e-30ba-03e5-fda168661d21" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="ac4dd5be-1b73-8b96-03ed-e7d08a5c07ca" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="cda32bb8-6e5c-5eee-2a22-7d9743027bee" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="383e0048-68e2-3a4c-7e84-a85ac9a09c2d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny(System.Threading.Tasks.Task[],System.Func{System.Threading.Tasks.Task,`0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="fd39e336-70f6-d56e-d1b6-aa035df1daad" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0})" />
</specialization>
</type>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="f9f41785-4654-1647-cfc2-5b64be19e8e0" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken)" />
</specialization>
</type>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="98aec50b-d6a0-dbb8-07af-beaf23db56f4" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskContinuationOptions,System.Threading.Tasks.TaskScheduler)" />
</specialization>
</type>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="9cf752c7-cb83-885e-5915-81be172462f0" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)">
<topicdata group="api" />
<apidata name="ContinueWhenAny" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny" />
<proceduredata virtual="false" />
<templates>
<template name="TAntecedentResult" />
</templates>
<parameters>
<parameter name="tasks">
<arrayOf rank="1">
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
</arrayOf>
</parameter>
<parameter name="continuationFunction">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TAntecedentResult" index="0" api="M:System.Threading.Tasks.TaskFactory`1.ContinueWhenAny``1(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0},`0},System.Threading.Tasks.TaskContinuationOptions)" />
</specialization>
</type>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="continuationOptions">
<type api="T:System.Threading.Tasks.TaskContinuationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="6ab3dc2e-9253-98e3-7987-2c35601ff104" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory`1.CreationOptions">
<topicdata group="api" />
<apidata name="CreationOptions" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_CreationOptions" />
<returns>
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="1ca1f737-dd9c-a020-e484-8849a09d00a1" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="63f06be7-9f2e-5815-4c7b-b5af721dfc55" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.Func{System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`3" ref="true">
<specialization>
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="1e751187-1c96-a5e8-8210-0be8898a09b9" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="c5bdd18f-22eb-40fb-1ac5-dfd8e5a373a1" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`4" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``1(System.Func{``0,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="39f16395-0f23-65f7-262e-572992e02d72" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="2dc6386a-f16a-110a-dae3-c9332489efed" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`5" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``2(System.Func{``0,``1,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="dc577448-8bdc-a704-c7fc-9fefc4426d5d" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="224b6465-b6fb-b357-e15e-03c66876c604" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<templates>
<template name="TArg1" />
<template name="TArg2" />
<template name="TArg3" />
</templates>
<parameters>
<parameter name="beginMethod">
<type api="T:System.Func`6" ref="true">
<specialization>
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
<type api="T:System.AsyncCallback" ref="true" />
<type api="T:System.Object" ref="true" />
<type api="T:System.IAsyncResult" ref="true" />
</specialization>
</type>
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="arg1">
<template name="TArg1" index="0" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg2">
<template name="TArg2" index="1" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="arg3">
<template name="TArg3" index="2" api="M:System.Threading.Tasks.TaskFactory`1.FromAsync``3(System.Func{``0,``1,``2,System.AsyncCallback,System.Object,System.IAsyncResult},System.Func{System.IAsyncResult,`0},``0,``1,``2,System.Object,System.Threading.Tasks.TaskCreationOptions)" />
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="a495442c-e8a3-1fc9-050c-fba1392f503c" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0})">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="6d912122-a0e9-e6e8-7be4-4e204ba13809" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="f0f9ccef-758b-8f02-f715-9cfacec83b68" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.FromAsync(System.IAsyncResult,System.Func{System.IAsyncResult,`0},System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="FromAsync" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.FromAsync" />
<proceduredata virtual="false" />
<parameters>
<parameter name="asyncResult">
<type api="T:System.IAsyncResult" ref="true" />
</parameter>
<parameter name="endMethod">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.IAsyncResult" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="014d5abe-d241-798d-f050-327e627245c3" />
</api>
<api id="P:System.Threading.Tasks.TaskFactory`1.Scheduler">
<topicdata group="api" />
<apidata name="Scheduler" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Scheduler" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="a76bd2c6-bc84-f923-e8c5-71af8f50d353" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0})">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="69f2007f-75b7-0ef9-2aa5-81e0ab8ff1ba" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="f05a4300-3f5a-50c2-82c3-c82fae730683" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="5cc93105-f36c-1373-127b-5899b0a08fbe" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{`0},System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="4997e1f7-0c18-18e7-776f-0a5719fbe91a" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="14e0dd31-d018-6fda-ff9a-8118be34cde1" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="4f9efa70-6b7c-2b67-ae13-d162ba0efbac" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.CancellationToken,System.Threading.Tasks.TaskCreationOptions,System.Threading.Tasks.TaskScheduler)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="cancellationToken">
<type api="T:System.Threading.CancellationToken" ref="false" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
<parameter name="scheduler">
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="f4066da7-daac-cc31-429d-f9f80e1e0a04" />
</api>
<api id="M:System.Threading.Tasks.TaskFactory`1.StartNew(System.Func{System.Object,`0},System.Object,System.Threading.Tasks.TaskCreationOptions)">
<topicdata group="api" />
<apidata name="StartNew" group="member" subgroup="method" />
<memberdata visibility="public" overload="Overload:System.Threading.Tasks.TaskFactory`1.StartNew" />
<proceduredata virtual="false" />
<parameters>
<parameter name="function">
<type api="T:System.Func`2" ref="true">
<specialization>
<type api="T:System.Object" ref="true" />
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</parameter>
<parameter name="state">
<type api="T:System.Object" ref="true" />
</parameter>
<parameter name="creationOptions">
<type api="T:System.Threading.Tasks.TaskCreationOptions" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Threading.Tasks.Task`1" ref="true">
<specialization>
<template name="TResult" index="0" api="T:System.Threading.Tasks.TaskFactory`1" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskFactory`1" ref="true" />
</containers>
<file name="f2d54718-f536-d4d9-2adb-60fcbd7125bb" />
</api>
<api id="T:System.Threading.Tasks.TaskScheduler">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskScheduler" />
<apidata name="TaskScheduler" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" serializable="false" />
<family>
<ancestors>
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.Permissions.HostProtectionAttribute" ref="true" />
<argument>
<type api="T:System.Security.Permissions.SecurityAction" ref="false" />
<enumValue>
<field name="LinkDemand" />
</enumValue>
</argument>
<assignment name="Synchronization">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
<assignment name="ExternalThreading">
<type api="T:System.Boolean" ref="false" />
<value>True</value>
</assignment>
</attribute>
</attributes>
<file name="6f4a6ab7-9677-282f-8ff3-c2d785809605" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskScheduler">
<topicdata name="TaskScheduler" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskScheduler" />
<apidata name="TaskScheduler" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.TaskScheduler.#ctor" />
<element api="P:System.Threading.Tasks.TaskScheduler.Current" />
<element api="P:System.Threading.Tasks.TaskScheduler.Default" />
<element api="M:System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext" />
<element api="M:System.Threading.Tasks.TaskScheduler.GetScheduledTasks" />
<element api="P:System.Threading.Tasks.TaskScheduler.Id" />
<element api="P:System.Threading.Tasks.TaskScheduler.MaximumConcurrencyLevel" />
<element api="M:System.Threading.Tasks.TaskScheduler.QueueTask(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryDequeue(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryExecuteTask(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryExecuteTaskInline(System.Threading.Tasks.Task,System.Boolean)" />
<element api="E:System.Threading.Tasks.TaskScheduler.UnobservedTaskException" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" />
</containers>
<file name="f97df7b9-1e09-da5c-27d2-a5ef0de98586" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskScheduler">
<topicdata name="TaskScheduler" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskScheduler" />
<apidata name="TaskScheduler" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext" />
<element api="M:System.Threading.Tasks.TaskScheduler.GetScheduledTasks" />
<element api="M:System.Threading.Tasks.TaskScheduler.QueueTask(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryDequeue(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryExecuteTask(System.Threading.Tasks.Task)" />
<element api="M:System.Threading.Tasks.TaskScheduler.TryExecuteTaskInline(System.Threading.Tasks.Task,System.Boolean)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" />
</containers>
<file name="551f3f39-b6a7-e878-9f4d-c329c70a4ceb" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskScheduler">
<topicdata name="TaskScheduler" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskScheduler" />
<apidata name="TaskScheduler" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" serializable="false" />
<elements>
<element api="P:System.Threading.Tasks.TaskScheduler.Current" />
<element api="P:System.Threading.Tasks.TaskScheduler.Default" />
<element api="P:System.Threading.Tasks.TaskScheduler.Id" />
<element api="P:System.Threading.Tasks.TaskScheduler.MaximumConcurrencyLevel" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" />
</containers>
<file name="958d34c4-75ee-4b69-d5ce-0c858f1dec49" />
</api>
<api id="Events.T:System.Threading.Tasks.TaskScheduler">
<topicdata name="TaskScheduler" group="list" subgroup="Events" typeTopicId="T:System.Threading.Tasks.TaskScheduler" />
<apidata name="TaskScheduler" group="type" subgroup="class" />
<typedata visibility="public" abstract="true" serializable="false" />
<elements>
<element api="E:System.Threading.Tasks.TaskScheduler.UnobservedTaskException" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" />
</containers>
<file name="351b1f76-5dfe-1f6c-3234-590f33679f4f" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="family" special="true" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="a98bc615-7424-bfcc-cae7-1745a3af7d97" />
</api>
<api id="P:System.Threading.Tasks.TaskScheduler.Current">
<topicdata group="api" />
<apidata name="Current" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Current" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="bcee1d3b-6aaa-9009-2261-fb770bfab24e" />
</api>
<api id="P:System.Threading.Tasks.TaskScheduler.Default">
<topicdata group="api" />
<apidata name="Default" group="member" subgroup="property" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Default" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="b38ca3d4-08e3-1855-0fb9-a50684d9b7ef" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext">
<topicdata group="api" />
<apidata name="FromCurrentSynchronizationContext" group="member" subgroup="method" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<returns>
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="1e0c79a8-8660-5dae-8de5-1f8c8613e52d" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.GetScheduledTasks">
<topicdata group="api" />
<apidata name="GetScheduledTasks" group="member" subgroup="method" />
<memberdata visibility="family" />
<proceduredata abstract="true" virtual="true" />
<returns>
<type api="T:System.Collections.Generic.IEnumerable`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.Task" ref="true" />
</specialization>
</type>
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
<file name="2f256400-55c5-c37c-b58c-b369a67587a0" />
</api>
<api id="P:System.Threading.Tasks.TaskScheduler.Id">
<topicdata group="api" />
<apidata name="Id" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Id" />
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="ef6858b5-5060-01ed-3959-ff2b6dc39f73" />
</api>
<api id="P:System.Threading.Tasks.TaskScheduler.MaximumConcurrencyLevel">
<topicdata group="api" />
<apidata name="MaximumConcurrencyLevel" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="true" />
<propertydata get="true" />
<getter name="get_MaximumConcurrencyLevel" />
<returns>
<type api="T:System.Int32" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="f4cc2b83-2eb3-d069-4ea8-7643bd0f1c16" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.QueueTask(System.Threading.Tasks.Task)">
<topicdata group="api" />
<apidata name="QueueTask" group="member" subgroup="method" />
<memberdata visibility="family" />
<proceduredata abstract="true" virtual="true" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
<file name="36c42414-e9ff-3608-1435-d812ce19f6f4" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.TryDequeue(System.Threading.Tasks.Task)">
<topicdata group="api" />
<apidata name="TryDequeue" group="member" subgroup="method" />
<memberdata visibility="family" />
<proceduredata virtual="true" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
<file name="e10db4d4-df09-dc6a-c5fc-c2ea765ffec2" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.TryExecuteTask(System.Threading.Tasks.Task)">
<topicdata group="api" />
<apidata name="TryExecuteTask" group="member" subgroup="method" />
<memberdata visibility="family" />
<proceduredata virtual="false" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
<file name="02be4e17-78e8-b1ac-9554-9a04d08643ae" />
</api>
<api id="M:System.Threading.Tasks.TaskScheduler.TryExecuteTaskInline(System.Threading.Tasks.Task,System.Boolean)">
<topicdata group="api" />
<apidata name="TryExecuteTaskInline" group="member" subgroup="method" />
<memberdata visibility="family" />
<proceduredata abstract="true" virtual="true" />
<parameters>
<parameter name="task">
<type api="T:System.Threading.Tasks.Task" ref="true" />
</parameter>
<parameter name="taskWasPreviouslyQueued">
<type api="T:System.Boolean" ref="false" />
</parameter>
</parameters>
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
<file name="20a9b11b-0ff7-624e-c6dd-3a7dccc9eda5" />
</api>
<api id="E:System.Threading.Tasks.TaskScheduler.UnobservedTaskException">
<topicdata group="api" />
<apidata name="UnobservedTaskException" group="member" subgroup="event" />
<memberdata visibility="public" static="true" />
<proceduredata virtual="false" />
<eventdata add="true" remove="true" />
<adder name="add_UnobservedTaskException">
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
</adder>
<remover name="remove_UnobservedTaskException">
<attributes>
<attribute>
<type api="T:System.Security.SecurityCriticalAttribute" ref="true" />
</attribute>
</attributes>
</remover>
<eventhandler>
<type api="T:System.EventHandler`1" ref="true">
<specialization>
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</specialization>
</type>
</eventhandler>
<eventargs>
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</eventargs>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskScheduler" ref="true" />
</containers>
<file name="36db9ce5-c85b-ca2b-8da4-d9805dd0369b" />
</api>
<api id="T:System.Threading.Tasks.TaskSchedulerException">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name="TaskSchedulerException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<family>
<ancestors>
<type api="T:System.Exception" ref="true" />
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="681a176d-78ca-5fe9-560d-c827390156c3" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.TaskSchedulerException">
<topicdata name="TaskSchedulerException" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name="TaskSchedulerException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<elements>
<element api="P:System.Exception.Data" />
<element api="M:System.Exception.GetBaseException" />
<element api="M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Exception.GetType" />
<element api="P:System.Exception.HelpLink" />
<element api="P:System.Exception.HResult" />
<element api="P:System.Exception.InnerException" />
<element api="P:System.Exception.Message" />
<element api="E:System.Exception.SerializeObjectState" />
<element api="P:System.Exception.Source" />
<element api="P:System.Exception.StackTrace" />
<element api="P:System.Exception.TargetSite" />
<element api="M:System.Exception.ToString" />
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.MemberwiseClone" />
<element api="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor">
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception)" />
</element>
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" />
</containers>
<file name="0ebab866-48bd-d095-060c-700e0bcd8eb2" />
</api>
<api id="Methods.T:System.Threading.Tasks.TaskSchedulerException">
<topicdata name="TaskSchedulerException" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name="TaskSchedulerException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<elements>
<element api="M:System.Exception.GetBaseException" />
<element api="M:System.Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Exception.GetType" />
<element api="M:System.Exception.ToString" />
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.MemberwiseClone" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" />
</containers>
<file name="7c74b0ca-6559-7bc2-0f15-1b48b25222f9" />
</api>
<api id="Properties.T:System.Threading.Tasks.TaskSchedulerException">
<topicdata name="TaskSchedulerException" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name="TaskSchedulerException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<elements>
<element api="P:System.Exception.Data" />
<element api="P:System.Exception.HelpLink" />
<element api="P:System.Exception.HResult" />
<element api="P:System.Exception.InnerException" />
<element api="P:System.Exception.Message" />
<element api="P:System.Exception.Source" />
<element api="P:System.Exception.StackTrace" />
<element api="P:System.Exception.TargetSite" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" />
</containers>
<file name="4e27f517-756e-2ec1-58fd-0882a652e879" />
</api>
<api id="Events.T:System.Threading.Tasks.TaskSchedulerException">
<topicdata name="TaskSchedulerException" group="list" subgroup="Events" typeTopicId="T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name="TaskSchedulerException" group="type" subgroup="class" />
<typedata visibility="public" serializable="true" defaultConstructor="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<elements>
<element api="E:System.Exception.SerializeObjectState" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" />
</containers>
<file name="5f9ac0db-ee78-5528-96aa-c43936f71d24" />
</api>
<api id="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor">
<topicdata name=".ctor" group="list" subgroup="overload" memberSubgroup="constructor" pseudo="true" allMembersTopicId="AllMembers.T:System.Threading.Tasks.TaskSchedulerException" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<elements>
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)" />
<element api="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception)" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="236d56f8-8e23-f592-5914-ee754f6263c6" />
</api>
<api id="M:System.Threading.Tasks.TaskSchedulerException.#ctor">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="18da2b99-e96e-7880-7d36-e990d0e38380" />
</api>
<api id="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Exception)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<parameters>
<parameter name="innerException">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="93e55947-1ee7-4243-46bb-d2811a5bc854" />
</api>
<api id="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="family" special="true" overload="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<parameters>
<parameter name="info">
<type api="T:System.Runtime.Serialization.SerializationInfo" ref="true" />
</parameter>
<parameter name="context">
<type api="T:System.Runtime.Serialization.StreamingContext" ref="false" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="5521bbcb-6597-3e63-453c-c2436c4f7e8f" />
</api>
<api id="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<parameters>
<parameter name="message">
<type api="T:System.String" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="132b2f9e-5d72-2ffd-3413-21e4c0bcce85" />
</api>
<api id="M:System.Threading.Tasks.TaskSchedulerException.#ctor(System.String,System.Exception)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" overload="Overload:System.Threading.Tasks.TaskSchedulerException.#ctor" />
<parameters>
<parameter name="message">
<type api="T:System.String" ref="true" />
</parameter>
<parameter name="innerException">
<type api="T:System.Exception" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskSchedulerException" ref="true" />
</containers>
<file name="d557ebcf-578f-be8d-ec53-47c5449a9279" />
</api>
<api id="T:System.Threading.Tasks.TaskStatus">
<topicdata group="api" />
<apidata name="TaskStatus" group="type" subgroup="enumeration" />
<typedata visibility="public" sealed="true" serializable="false" />
<elements>
<element api="F:System.Threading.Tasks.TaskStatus.Created" />
<element api="F:System.Threading.Tasks.TaskStatus.WaitingForActivation" />
<element api="F:System.Threading.Tasks.TaskStatus.WaitingToRun" />
<element api="F:System.Threading.Tasks.TaskStatus.Running" />
<element api="F:System.Threading.Tasks.TaskStatus.WaitingForChildrenToComplete" />
<element api="F:System.Threading.Tasks.TaskStatus.RanToCompletion" />
<element api="F:System.Threading.Tasks.TaskStatus.Canceled" />
<element api="F:System.Threading.Tasks.TaskStatus.Faulted" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="538e5879-824a-26b8-4e53-7150eb18ded9" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.Canceled">
<topicdata group="api" notopic="" />
<apidata name="Canceled" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>6</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="862f74c0-e95e-11be-e376-0e1d6a942784" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.Created">
<topicdata group="api" notopic="" />
<apidata name="Created" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>0</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="d6ab4545-79d5-9108-d509-b6bf445fe3e6" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.Faulted">
<topicdata group="api" notopic="" />
<apidata name="Faulted" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>7</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="909303a8-89df-2a28-5e52-44a991035f22" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.RanToCompletion">
<topicdata group="api" notopic="" />
<apidata name="RanToCompletion" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>5</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="c09fe672-11e8-d2b3-c7f4-ec351468f35d" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.Running">
<topicdata group="api" notopic="" />
<apidata name="Running" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>3</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="ec368fea-3360-13be-5eb0-851a56494daf" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.WaitingForActivation">
<topicdata group="api" notopic="" />
<apidata name="WaitingForActivation" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>1</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="8f9079cd-50c6-e40b-a314-e015487f59ec" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.WaitingForChildrenToComplete">
<topicdata group="api" notopic="" />
<apidata name="WaitingForChildrenToComplete" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>4</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="35684f18-166e-a87b-51df-33a0f1410b37" />
</api>
<api id="F:System.Threading.Tasks.TaskStatus.WaitingToRun">
<topicdata group="api" notopic="" />
<apidata name="WaitingToRun" group="member" subgroup="field" />
<memberdata visibility="public" static="true" />
<fielddata literal="true" initonly="false" serialized="true" />
<returns>
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</returns>
<value>2</value>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.TaskStatus" ref="false" />
</containers>
<file name="a4f0a851-119d-6a8a-fc9f-a7e98820221f" />
</api>
<api id="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs">
<topicdata group="api" allMembersTopicId="AllMembers.T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
<apidata name="UnobservedTaskExceptionEventArgs" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<family>
<ancestors>
<type api="T:System.EventArgs" ref="true" />
<type api="T:System.Object" ref="true" />
</ancestors>
</family>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
</containers>
<file name="a3cd672e-c430-e6c4-b090-9135a8388a65" />
</api>
<api id="AllMembers.T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs">
<topicdata name="UnobservedTaskExceptionEventArgs" group="list" subgroup="members" typeTopicId="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
<apidata name="UnobservedTaskExceptionEventArgs" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.#ctor(System.AggregateException)" />
<element api="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Exception" />
<element api="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Observed" />
<element api="M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
</containers>
<file name="b918a41f-9059-576c-601e-e0e718119f67" />
</api>
<api id="Methods.T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs">
<topicdata name="UnobservedTaskExceptionEventArgs" group="list" subgroup="Methods" typeTopicId="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
<apidata name="UnobservedTaskExceptionEventArgs" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="M:System.Object.Equals(System.Object)" />
<element api="M:System.Object.Finalize" />
<element api="M:System.Object.GetHashCode" />
<element api="M:System.Object.GetType" />
<element api="M:System.Object.MemberwiseClone" />
<element api="M:System.Object.ToString" />
<element api="M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
</containers>
<file name="85e26ed3-cbf5-c936-0e74-b814cc97a620" />
</api>
<api id="Properties.T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs">
<topicdata name="UnobservedTaskExceptionEventArgs" group="list" subgroup="Properties" typeTopicId="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
<apidata name="UnobservedTaskExceptionEventArgs" group="type" subgroup="class" />
<typedata visibility="public" serializable="false" />
<elements>
<element api="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Exception" />
<element api="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Observed" />
</elements>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" />
</containers>
<file name="cc0e88ba-a746-a9c6-449b-73812a95d460" />
</api>
<api id="M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.#ctor(System.AggregateException)">
<topicdata group="api" />
<apidata name=".ctor" group="member" subgroup="constructor" />
<memberdata visibility="public" special="true" />
<parameters>
<parameter name="exception">
<type api="T:System.AggregateException" ref="true" />
</parameter>
</parameters>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</containers>
<file name="5d5488b8-a1b1-a46c-c922-2175c4884a73" />
</api>
<api id="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Exception">
<topicdata group="api" />
<apidata name="Exception" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Exception" />
<returns>
<type api="T:System.AggregateException" ref="true" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</containers>
<file name="ba3e4858-e5f0-e04d-fe5b-2f41fa34806a" />
</api>
<api id="P:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.Observed">
<topicdata group="api" />
<apidata name="Observed" group="member" subgroup="property" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<propertydata get="true" />
<getter name="get_Observed" />
<returns>
<type api="T:System.Boolean" ref="false" />
</returns>
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</containers>
<file name="58117f95-47b9-ee20-22a9-2ed6b0fbf4fa" />
</api>
<api id="M:System.Threading.Tasks.UnobservedTaskExceptionEventArgs.SetObserved">
<topicdata group="api" />
<apidata name="SetObserved" group="member" subgroup="method" />
<memberdata visibility="public" />
<proceduredata virtual="false" />
<containers>
<library assembly="mscorlib" module="mscorlib" kind="DynamicallyLinkedLibrary">
<assemblydata version="4.6.81.0" />
</library>
<namespace api="N:System.Threading.Tasks" />
<type api="T:System.Threading.Tasks.UnobservedTaskExceptionEventArgs" ref="true" />
</containers>
<file name="75b8570e-3c00-7b0f-da64-7503676302aa" />
</api>
</apis>
</reflection> | {'content_hash': '58148281d12319930cad941cfdc5611b', 'timestamp': '', 'source': 'github', 'line_count': 15305, 'max_line_length': 603, 'avg_line_length': 57.7421757595557, 'alnum_prop': 0.6407455100119491, 'repo_name': 'kevindaub/NLog', 'id': 'a28e2176e69f2ff29e8d7e1bb8622aa0eda75e00', 'size': '883750', 'binary': False, 'copies': '8', 'ref': 'refs/heads/master', 'path': 'tools/SHFB/Data/.NETFramework/System.Threading.Tasks.xml', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'ASP', 'bytes': '2613'}, {'name': 'Batchfile', 'bytes': '521'}, {'name': 'C#', 'bytes': '4024662'}, {'name': 'Makefile', 'bytes': '3639'}, {'name': 'Perl', 'bytes': '1590'}, {'name': 'PowerShell', 'bytes': '1596'}]} |
package fake
import (
v1beta1 "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/storage/v1beta1"
restclient "k8s.io/kubernetes/pkg/client/restclient"
core "k8s.io/kubernetes/pkg/client/testing/core"
)
type FakeStorage struct {
*core.Fake
}
func (c *FakeStorage) StorageClasses() v1beta1.StorageClassInterface {
return &FakeStorageClasses{c}
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *FakeStorage) RESTClient() restclient.Interface {
var ret *restclient.RESTClient
return ret
}
| {'content_hash': 'ada56adfa557a9836d35f196537a32a4', 'timestamp': '', 'source': 'github', 'line_count': 24, 'max_line_length': 93, 'avg_line_length': 24.541666666666668, 'alnum_prop': 0.7792869269949066, 'repo_name': 'jimmycuadra/kubernetes', 'id': 'b145ba06cdc2d5e5ed121bf4e3b111a1b114e420', 'size': '1158', 'binary': False, 'copies': '6', 'ref': 'refs/heads/master', 'path': 'pkg/client/clientset_generated/release_1_5/typed/storage/v1beta1/fake/fake_storage_client.go', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'C', 'bytes': '978'}, {'name': 'Go', 'bytes': '44743671'}, {'name': 'HTML', 'bytes': '2251615'}, {'name': 'Makefile', 'bytes': '71418'}, {'name': 'Nginx', 'bytes': '1013'}, {'name': 'Protocol Buffer', 'bytes': '571151'}, {'name': 'Python', 'bytes': '911288'}, {'name': 'SaltStack', 'bytes': '54088'}, {'name': 'Shell', 'bytes': '1534661'}]} |
package com.cloudhopper.smpp.simulator;
import com.cloudhopper.smpp.SmppConstants;
import com.cloudhopper.smpp.pdu.BaseBind;
import com.cloudhopper.smpp.pdu.BaseBindResp;
import com.cloudhopper.smpp.pdu.Pdu;
import com.cloudhopper.smpp.pdu.PduRequest;
import org.jboss.netty.channel.Channel;
/**
*
* @author joelauer (twitter: @jjlauer or <a href="http://twitter.com/jjlauer" target=window>http://twitter.com/jjlauer</a>)
*/
public class SmppSimulatorBindProcessor implements SmppSimulatorPduProcessor {
private String systemId;
private String password;
public SmppSimulatorBindProcessor(String systemId, String password) {
this.systemId = systemId;
this.password = password;
}
@Override
public boolean process(SmppSimulatorSessionHandler session, Channel channel, Pdu pdu) throws Exception {
// anything other than a bind is super bad!
if (!(pdu instanceof BaseBind)) {
if (pdu instanceof PduRequest) {
session.addPduToWriteOnNextPduReceived(((PduRequest)pdu).createGenericNack(SmppConstants.STATUS_INVBNDSTS));
return true;
} else {
//logger.error("PDU response received, but not bound");
channel.close();
return true;
}
}
BaseBind bind = (BaseBind)pdu;
BaseBindResp bindResp = (BaseBindResp)bind.createResponse();
if (!bind.getSystemId().equals(systemId)) {
bindResp.setCommandStatus(SmppConstants.STATUS_INVSYSID);
} else if (!bind.getPassword().equals(password)) {
bindResp.setCommandStatus(SmppConstants.STATUS_INVPASWD);
}
session.addPduToWriteOnNextPduReceived(bindResp);
return true;
}
}
| {'content_hash': '9a73ad32e2e79fd517c523db4ffa0c78', 'timestamp': '', 'source': 'github', 'line_count': 53, 'max_line_length': 124, 'avg_line_length': 33.56603773584906, 'alnum_prop': 0.6711635750421585, 'repo_name': 'vaavaa/cloudhopper-smpp', 'id': 'd0dec6f041f869761185c972fdaaf39c92529e35', 'size': '2432', 'binary': False, 'copies': '8', 'ref': 'refs/heads/master', 'path': 'src/main/java/com/cloudhopper/smpp/simulator/SmppSimulatorBindProcessor.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '859802'}, {'name': 'Makefile', 'bytes': '1577'}]} |
//
// EBAppDelegate.h
// EBPhotoPageViewControllerDemo
//
// Created by Eddy Borja.
// Copyright (c) 2014 Eddy Borja. All rights reserved.
//
#import <UIKit/UIKit.h>
@class DEMOViewController;
@interface DEMOAppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window;
@property (strong, nonatomic) DEMOViewController *viewController;
@end
| {'content_hash': 'b01d7ad2ab39a2c56ea990505ea23376', 'timestamp': '', 'source': 'github', 'line_count': 21, 'max_line_length': 65, 'avg_line_length': 18.523809523809526, 'alnum_prop': 0.7506426735218509, 'repo_name': 'jiamaozheng/EBPhotoPages', 'id': '27352b17d368d10f14e62656429ead58869cd854', 'size': '1423', 'binary': False, 'copies': '15', 'ref': 'refs/heads/master', 'path': 'EBPhotoPagesControllerDemo/DEMOAppDelegate.h', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Objective-C', 'bytes': '373371'}, {'name': 'Ruby', 'bytes': '1581'}]} |
package org.springframework.cloud.dataflow.core;
import org.springframework.util.StringUtils;
/**
* @author Christian Tzolov
*/
public class DefinitionUtils {
public static String escapeNewlines(String propertyValue) {
if (!StringUtils.hasText(propertyValue)) {
return propertyValue;
}
return propertyValue.replace("\n", "\\n");
}
public static String autoQuotes(String propertyValue) {
if (!StringUtils.hasText(propertyValue)) {
return propertyValue;
}
if (propertyValue.startsWith("\"") && propertyValue.endsWith("\"")) {
return propertyValue;
}
String result = propertyValue;
if (!propertyValue.contains("'")) {
if (propertyValue.contains(" ") || propertyValue.contains(";") || propertyValue.contains("*")) {
result = "'" + propertyValue + "'";
}
}
else {
if (propertyValue.contains(" ") || propertyValue.contains(";") || propertyValue.contains("*")) {
result = "\"" + propertyValue + "\"";
}
}
return result;
}
}
| {'content_hash': '8cb8f95ff80566ca04db22d32cc002e8', 'timestamp': '', 'source': 'github', 'line_count': 43, 'max_line_length': 99, 'avg_line_length': 22.976744186046513, 'alnum_prop': 0.6629554655870445, 'repo_name': 'ilayaperumalg/spring-cloud-dataflow', 'id': '9e0572a71eda6772eba951a921723258ff4d174d', 'size': '1609', 'binary': False, 'copies': '10', 'ref': 'refs/heads/master', 'path': 'spring-cloud-dataflow-core/src/main/java/org/springframework/cloud/dataflow/core/DefinitionUtils.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Dockerfile', 'bytes': '889'}, {'name': 'Java', 'bytes': '3354922'}, {'name': 'Ruby', 'bytes': '423'}, {'name': 'Shell', 'bytes': '5861'}, {'name': 'TSQL', 'bytes': '5083'}, {'name': 'Vim Snippet', 'bytes': '190'}, {'name': 'XSLT', 'bytes': '863'}]} |
package io.cloudslang.content.amazon.actions.instances;
import com.hp.oo.sdk.content.annotations.Action;
import com.hp.oo.sdk.content.annotations.Output;
import com.hp.oo.sdk.content.annotations.Param;
import com.hp.oo.sdk.content.annotations.Response;
import com.hp.oo.sdk.content.plugin.ActionMetadata.MatchType;
import com.hp.oo.sdk.content.plugin.ActionMetadata.ResponseType;
import io.cloudslang.content.amazon.entities.constants.Outputs;
import io.cloudslang.content.amazon.entities.inputs.CommonInputs;
import io.cloudslang.content.amazon.entities.inputs.InstanceInputs;
import io.cloudslang.content.amazon.execute.QueryApiExecutor;
import io.cloudslang.content.amazon.utils.ExceptionProcessor;
import java.util.Map;
import static io.cloudslang.content.amazon.utils.InputsUtil.getDefaultStringInput;
import static io.cloudslang.content.amazon.entities.constants.Constants.Apis.EC2_API;
import static io.cloudslang.content.amazon.entities.constants.Constants.DefaultApiVersion.INSTANCES_DEFAULT_API_VERSION;
import static io.cloudslang.content.amazon.entities.constants.Constants.AwsParams.HTTP_CLIENT_METHOD_GET;
import static io.cloudslang.content.amazon.entities.constants.Constants.Miscellaneous.EMPTY;
import static io.cloudslang.content.amazon.entities.constants.Constants.Ec2QueryApiActions.REBOOT_INSTANCES;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.CREDENTIAL;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.DELIMITER;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.ENDPOINT;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.HEADERS;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.IDENTITY;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.PROXY_HOST;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.PROXY_PASSWORD;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.PROXY_PORT;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.PROXY_USERNAME;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.QUERY_PARAMS;
import static io.cloudslang.content.amazon.entities.constants.Inputs.CommonInputs.VERSION;
import static io.cloudslang.content.amazon.entities.constants.Inputs.InstanceInputs.INSTANCE_IDS_STRING;
/**
* Created by persdana
* 6/22/2015.
*/
public class RebootInstancesAction {
/**
* Requests a reboot of one or more instances.
* Note: This operation is asynchronous; it only queues a request to reboot the specified instances. The operation
* succeeds if the instances are valid and belong to you. Requests to reboot terminated instances are ignored.
* If an instance does not cleanly shut down within four minutes, Amazon EC2 performs a hard reboot.
* For more information about troubleshooting, see Getting Console Output and Rebooting Instances
* http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html in the Amazon Elastic Compute Cloud User
* Guide.
*
* @param endpoint Optional - Endpoint to which request will be sent.
* Default: "https://ec2.amazonaws.com"
* @param identity ID of the secret access key associated with your Amazon AWS or IAM account.
* Example: "AKIAIOSFODNN7EXAMPLE"
* @param credential Secret access key associated with your Amazon AWS or IAM account.
* Example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
* @param proxyHost Optional - proxy server used to connect to Amazon API. If empty no proxy will be used.
* Default: ""
* @param proxyPort Optional - proxy server port. You must either specify values for both proxyHost and
* proxyPort inputs or leave them both empty.
* Default: ""
* @param proxyUsername Optional - proxy server user name.
* Default: ""
* @param proxyPassword Optional - proxy server password associated with the proxyUsername input value.
* Default: ""
* @param headers Optional - string containing the headers to use for the request separated by new line (CRLF).
* The header name-value pair will be separated by ":".
* Format: Conforming with HTTP standard for headers (RFC 2616)
* Examples: "Accept:text/plain"
* Default: ""
* @param queryParams Optional - string containing query parameters that will be appended to the URL. The names
* and the values must not be URL encoded because if they are encoded then a double encoded
* will occur. The separator between name-value pairs is "&" symbol. The query name will be
* separated from query value by "=".
* Examples: "parameterName1=parameterValue1¶meterName2=parameterValue2"
* Default: ""
* @param version Optional - Version of the web service to made the call against it.
* Example: "2016-11-15"
* Default: "2016-11-15"
* @param delimiter Optional - delimiter that will be used.
* Default: ","
* @param instanceIdsString String that contains one or more values that represents instance IDs.
* Example: "i-12345678,i-abcdef12,i-12ab34cd"
* @return A map with strings as keys and strings as values that contains: outcome of the action (or failure message
* and the exception if there is one), returnCode of the operation and the ID of the request.
*/
@Action(name = "Reboot Instances",
outputs = {
@Output(Outputs.RETURN_CODE),
@Output(Outputs.RETURN_RESULT),
@Output(Outputs.EXCEPTION)
},
responses = {
@Response(text = Outputs.SUCCESS, field = Outputs.RETURN_CODE, value = Outputs.SUCCESS_RETURN_CODE,
matchType = MatchType.COMPARE_EQUAL, responseType = ResponseType.RESOLVED),
@Response(text = Outputs.FAILURE, field = Outputs.RETURN_CODE, value = Outputs.FAILURE_RETURN_CODE,
matchType = MatchType.COMPARE_EQUAL, responseType = ResponseType.ERROR)
}
)
public Map<String, String> execute(@Param(value = ENDPOINT) String endpoint,
@Param(value = IDENTITY, required = true) String identity,
@Param(value = CREDENTIAL, required = true, encrypted = true) String credential,
@Param(value = PROXY_HOST) String proxyHost,
@Param(value = PROXY_PORT) String proxyPort,
@Param(value = PROXY_USERNAME) String proxyUsername,
@Param(value = PROXY_PASSWORD, encrypted = true) String proxyPassword,
@Param(value = HEADERS) String headers,
@Param(value = QUERY_PARAMS) String queryParams,
@Param(value = VERSION) String version,
@Param(value = DELIMITER) String delimiter,
@Param(value = INSTANCE_IDS_STRING, required = true) String instanceIdsString) {
try {
version = getDefaultStringInput(version, INSTANCES_DEFAULT_API_VERSION);
final CommonInputs commonInputs = new CommonInputs.Builder()
.withEndpoint(endpoint, EC2_API, EMPTY)
.withIdentity(identity)
.withCredential(credential)
.withProxyHost(proxyHost)
.withProxyPort(proxyPort)
.withProxyUsername(proxyUsername)
.withProxyPassword(proxyPassword)
.withHeaders(headers)
.withQueryParams(queryParams)
.withVersion(version)
.withDelimiter(delimiter)
.withAction(REBOOT_INSTANCES)
.withApiService(EC2_API)
.withRequestUri(EMPTY)
.withRequestPayload(EMPTY)
.withHttpClientMethod(HTTP_CLIENT_METHOD_GET)
.build();
final InstanceInputs instanceInputs = new InstanceInputs.Builder()
.withInstanceIdsString(instanceIdsString)
.build();
return new QueryApiExecutor().execute(commonInputs, instanceInputs);
} catch (Exception e) {
return ExceptionProcessor.getExceptionResult(e);
}
}
}
| {'content_hash': 'bb6043cf110a84f032d94b78813c41c3', 'timestamp': '', 'source': 'github', 'line_count': 144, 'max_line_length': 125, 'avg_line_length': 64.40972222222223, 'alnum_prop': 0.6350404312668464, 'repo_name': 'victorursan/cs-actions', 'id': '75aa15edfcb0633e3717730b4790145704dc87b5', 'size': '9759', 'binary': False, 'copies': '2', 'ref': 'refs/heads/master', 'path': 'cs-amazon/src/main/java/io/cloudslang/content/amazon/actions/instances/RebootInstancesAction.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '3870134'}, {'name': 'Scala', 'bytes': '196306'}, {'name': 'XSLT', 'bytes': '544'}]} |
package io.gatling.recorder.har
import java.io.{ FileInputStream, InputStream }
import java.net.URL
import scala.collection.breakOut
import scala.util.Try
import io.gatling.commons.util.Io._
import io.gatling.http.HeaderNames._
import io.gatling.http.fetch.HtmlParser
import io.gatling.recorder.config.RecorderConfiguration
import io.gatling.recorder.scenario._
import org.asynchttpclient.uri.Uri
import io.netty.handler.codec.http.HttpMethod
/**
* Implementation according to http://www.softwareishard.com/blog/har-12-spec/
*/
private[recorder] object HarReader {
def apply(path: String)(implicit config: RecorderConfiguration): ScenarioDefinition =
withCloseable(new FileInputStream(path))(apply(_))
def apply(jsonStream: InputStream)(implicit config: RecorderConfiguration): ScenarioDefinition =
apply(Json.parseJson(jsonStream))
private def apply(json: Json)(implicit config: RecorderConfiguration): ScenarioDefinition = {
val HttpArchive(Log(entries)) = HarMapping.jsonToHttpArchive(json)
val elements = entries.iterator
.filter(e => e.request.method != HttpMethod.CONNECT.name)
.filter(e => isValidURL(e.request.url))
// TODO NICO : can't we move this in Scenario as well ?
.filter(e => config.filters.filters.map(_.accept(e.request.url)).getOrElse(true))
.map(createRequestWithArrivalTime)
.toVector
ScenarioDefinition(elements, Nil)
}
private def createRequestWithArrivalTime(entry: Entry): TimedScenarioElement[RequestElement] = {
def buildContent(postParams: Seq[PostParam]): RequestBody =
RequestBodyParams(postParams.map(postParam => (postParam.name, postParam.value)).toList)
val uri = entry.request.url
val method = entry.request.method
val requestHeaders = buildRequestHeaders(entry)
// NetExport doesn't copy post params to text field
val requestBody = entry.request.postData.flatMap { postData =>
if (postData.params.nonEmpty)
Some(buildContent(postData.params))
else
postData.textAsBytes map RequestBodyBytes
}
val responseBody = entry.response.content.textAsBytes map ResponseBodyBytes
val embeddedResources = entry.response.content match {
case Content("text/html", Some(text)) =>
val userAgent = requestHeaders.get(UserAgent).flatMap(io.gatling.http.fetch.UserAgent.parseFromHeader)
new HtmlParser().getEmbeddedResources(Uri.create(uri), text, userAgent)
case _ => Nil
}
TimedScenarioElement(entry.sendTime, entry.sendTime, RequestElement(uri, method, requestHeaders, requestBody, responseBody, entry.response.status, embeddedResources))
}
private def buildRequestHeaders(entry: Entry): Map[String, String] = {
// Chrome adds extra headers, eg: ":host". We should have them in the Gatling scenario.
val headers: Map[String, String] = entry.request.headers.filter(!_.name.startsWith(":")).map(h => (h.name, h.value))(breakOut)
// NetExport doesn't add Content-Type to headers when POSTing, but both Chrome Dev Tools and NetExport set mimeType
entry.request.postData.map(postData => headers.updated(ContentType, postData.mimeType)).getOrElse(headers)
}
private def isValidURL(url: String): Boolean = Try(new URL(url)).isSuccess
}
| {'content_hash': '00f13bfd733896f2e6b42b34310fe00a', 'timestamp': '', 'source': 'github', 'line_count': 81, 'max_line_length': 170, 'avg_line_length': 40.382716049382715, 'alnum_prop': 0.7419749312136961, 'repo_name': 'thkluge/gatling', 'id': '318f3e50fa413b009fc5e407b70bc23a60596ce7', 'size': '3888', 'binary': False, 'copies': '3', 'ref': 'refs/heads/master', 'path': 'gatling-recorder/src/main/scala/io/gatling/recorder/har/HarReader.scala', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Batchfile', 'bytes': '5080'}, {'name': 'CSS', 'bytes': '10422'}, {'name': 'HTML', 'bytes': '167248'}, {'name': 'JavaScript', 'bytes': '3690'}, {'name': 'Python', 'bytes': '7472'}, {'name': 'Scala', 'bytes': '1777537'}, {'name': 'Shell', 'bytes': '6122'}]} |
tQuery.Mesh.registerInstance('linkify', function(url){
var mesh = tQuery(this.get(0));
// measure mesh size
var size = mesh.geometry().computeAll().size();
// build the underline
var underlineH = size.y / 10;
var deltaY = size.y / 20;
var underline = tQuery.createCube(size.x, underlineH, size.z, mesh.get(0).material)
.translateY(-size.y/2 - deltaY - underlineH/2)
.addClass('underline')
// make it invisible by default
underline.get(0).visible = false;
// add it to the mesh
underline.addTo(mesh)
// the boundbing box to detect mouse events - make it invisible
var boundingBox = tQuery.createCube(size.x, size.y, size.z).addTo(mesh)
.visible(false)
// bind the click
boundingBox.on('click', function(event){
window.open(url, '_blank');
});
// bind 'mouseover'
boundingBox.on('mouseover', function(){
underline.get(0).visible = true;
document.body.style.cursor = 'pointer';
});
// bind 'mouseout'
boundingBox.on('mouseout', function(){
underline.get(0).visible = false;
document.body.style.cursor = 'default';
});
// return this for chained API
return this;
}); | {'content_hash': '0b874adb69aa37f8aa41c15c621f5635', 'timestamp': '', 'source': 'github', 'line_count': 37, 'max_line_length': 84, 'avg_line_length': 30.054054054054053, 'alnum_prop': 0.6861510791366906, 'repo_name': 'creatologist/sandbox-js', 'id': '8184e94adfdb3a913ca90935cde34eeb16431f10', 'size': '1112', 'binary': False, 'copies': '3', 'ref': 'refs/heads/master', 'path': 'threeJS/tquery/plugins/linkify/tquery.mesh.linkify.js', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '60339'}, {'name': 'C++', 'bytes': '25006'}, {'name': 'CSS', 'bytes': '43042'}, {'name': 'JavaScript', 'bytes': '12657025'}, {'name': 'Perl', 'bytes': '29915'}, {'name': 'Python', 'bytes': '238987'}, {'name': 'Ruby', 'bytes': '895'}, {'name': 'Shell', 'bytes': '2695'}]} |
/**
* @author benaadams / https://twitter.com/ben_a_adams
*/
THREE.InstancedInterleavedBuffer = function ( array, stride, meshPerAttribute ) {
THREE.InterleavedBuffer.call( this, array, stride );
this.meshPerAttribute = meshPerAttribute || 1;
};
THREE.InstancedInterleavedBuffer.prototype = Object.create( THREE.InterleavedBuffer.prototype );
THREE.InstancedInterleavedBuffer.prototype.constructor = THREE.InstancedInterleavedBuffer;
THREE.InstancedInterleavedBuffer.prototype.copy = function ( source ) {
THREE.InterleavedBuffer.prototype.copy.call( this, source );
this.meshPerAttribute = source.meshPerAttribute;
return this;
};
| {'content_hash': '4ddf628e11a229b1a298e9ed50c54e84', 'timestamp': '', 'source': 'github', 'line_count': 24, 'max_line_length': 96, 'avg_line_length': 28.041666666666668, 'alnum_prop': 0.7533432392273403, 'repo_name': 'krittika-IITB/krittika-IITB.github.io', 'id': 'd70523c74ec6001bdc029251c7c05812c060be53', 'size': '673', 'binary': False, 'copies': '40', 'ref': 'refs/heads/master', 'path': 'vrview/node_modules/three/src/core/InstancedInterleavedBuffer.js', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '32239'}, {'name': 'HTML', 'bytes': '41214'}, {'name': 'JavaScript', 'bytes': '2297974'}, {'name': 'PHP', 'bytes': '518'}, {'name': 'Ruby', 'bytes': '3528'}, {'name': 'Shell', 'bytes': '158'}]} |
The MIT License (MIT)
Copyright (c) 2017 Emanuele Mazzotta
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
| {'content_hash': '06bb23acfc247f10672f650b5e01a919', 'timestamp': '', 'source': 'github', 'line_count': 21, 'max_line_length': 78, 'avg_line_length': 51.61904761904762, 'alnum_prop': 0.8044280442804428, 'repo_name': 'emazzotta/showip', 'id': '51c8c91d777266be06f6b70e73617e4b7a08581a', 'size': '1084', 'binary': False, 'copies': '2', 'ref': 'refs/heads/master', 'path': 'LICENSE.md', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Shell', 'bytes': '1410'}]} |
/* License:
Oct. 3, 2008
Right to use this code in any way you want without warrenty, support or any guarentee of it working.
BOOK: It would be nice if you cited it:
Learning OpenCV: Computer Vision with the OpenCV Library
by Gary Bradski and Adrian Kaehler
Published by O'Reilly Media, October 3, 2008
AVAILABLE AT:
http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134
Or: http://oreilly.com/catalog/9780596516130/
ISBN-10: 0596516134 or: ISBN-13: 978-0596516130
OTHER OPENCV SITES:
* The source code is on sourceforge at:
http://sourceforge.net/projects/opencvlibrary/
* The OpenCV wiki page (As of Oct 1, 2008 this is down for changing over servers, but should come back):
http://opencvlibrary.sourceforge.net/
* An active user group is at:
http://tech.groups.yahoo.com/group/OpenCV/
* The minutes of weekly OpenCV development meetings are at:
http://pr.willowgarage.com/wiki/OpenCV
*/
#include "cv.h"
#include "highgui.h"
IplImage* doCanny(
IplImage* in,
double lowThresh,
double highThresh,
double aperture)
{
if (in->nChannels != 1)
return(0); // Canny only handles gray scale images
IplImage* out = cvCreateImage(
cvGetSize( in ),
in->depth, //IPL_DEPTH_8U,
1);
cvCanny( in, out, lowThresh, highThresh, aperture );
return( out );
};
int main( int argc, char** argv )
{
IplImage* img_rgb = cvLoadImage( argv[1] );
IplImage* img_gry = cvCreateImage( cvSize( img_rgb->width,img_rgb->height ), img_rgb->depth, 1);
cvCvtColor(img_rgb, img_gry ,CV_BGR2GRAY);
cvNamedWindow("Example Gray", CV_WINDOW_AUTOSIZE );
cvNamedWindow("Example Canny", CV_WINDOW_AUTOSIZE );
cvShowImage("Example Gray", img_gry );
IplImage* img_cny = doCanny( img_gry, 10, 100, 3 );
cvShowImage("Example Canny", img_cny );
cvWaitKey(0);
cvReleaseImage( &img_rgb);
cvReleaseImage( &img_gry);
cvReleaseImage( &img_cny);
cvDestroyWindow("Example Gray");
cvDestroyWindow("Example Canny");
}
| {'content_hash': '379fbb2e3239b5b12af32f1cb76bb86b', 'timestamp': '', 'source': 'github', 'line_count': 60, 'max_line_length': 107, 'avg_line_length': 34.583333333333336, 'alnum_prop': 0.6766265060240964, 'repo_name': 'gdijaejung/Learning-OpenCV', 'id': '6392576648ffc495b20f758b72a7f49bb5b83e35', 'size': '2075', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'example/ch2_ex2_6.cpp', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '12995'}, {'name': 'C++', 'bytes': '267778'}, {'name': 'HTML', 'bytes': '22881'}, {'name': 'Makefile', 'bytes': '3648'}]} |
FROM balenalib/n310-tx2-fedora:34-build
# http://bugs.python.org/issue19846
# > At the moment, setting "LANG=C" on a Linux system *fundamentally breaks Python 3*, and that's not OK.
ENV LANG C.UTF-8
RUN dnf install -y \
python3-pip \
python3-dbus \
&& dnf clean all
# install "virtualenv", since the vast majority of users of this image will want it
RUN pip3 install -U --no-cache-dir --ignore-installed pip setuptools \
&& pip3 install --no-cache-dir virtualenv
RUN [ ! -d /.balena/messages ] && mkdir -p /.balena/messages; echo $'As of January 1st, 2020, Python 2 was end-of-life, we will change the latest tag for Balenalib Python base image to Python 3.x and drop support for Python 2 soon. So after 1st July, 2020, all the balenalib Python latest tag will point to the latest Python 3 version and no changes, or fixes will be made to balenalib Python 2 base image. If you are using Python 2 for your application, please upgrade to Python 3 before 1st July.' > /.balena/messages/python-deprecation-warning
CMD ["echo","'No CMD command was set in Dockerfile! Details about CMD command could be found in Dockerfile Guide section in our Docs. Here's the link: https://balena.io/docs"]
RUN curl -SLO "https://raw.githubusercontent.com/balena-io-library/base-images/8accad6af708fca7271c5c65f18a86782e19f877/scripts/assets/tests/[email protected]" \
&& echo "Running test-stack@python" \
&& chmod +x [email protected] \
&& bash [email protected] \
&& rm -rf [email protected]
RUN [ ! -d /.balena/messages ] && mkdir -p /.balena/messages; echo $'Here are a few details about this Docker image (For more information please visit https://www.balena.io/docs/reference/base-images/base-images/): \nArchitecture: ARM v8 \nOS: Fedora 34 \nVariant: build variant \nDefault variable(s): UDEV=off \nThe following software stack is preinstalled: \nPython v3.10.2, Pip v21.3.1, Setuptools v60.5.4 \nExtra features: \n- Easy way to install packages with `install_packages <package-name>` command \n- Run anywhere with cross-build feature (for ARM only) \n- Keep the container idling with `balena-idle` command \n- Show base image details with `balena-info` command' > /.balena/messages/image-info
RUN echo $'#!/bin/sh.real\nbalena-info\nrm -f /bin/sh\ncp /bin/sh.real /bin/sh\n/bin/sh "$@"' > /bin/sh-shim \
&& chmod +x /bin/sh-shim \
&& cp /bin/sh /bin/sh.real \
&& mv /bin/sh-shim /bin/sh | {'content_hash': 'b5e6092425e24de3b592eb11c23da340', 'timestamp': '', 'source': 'github', 'line_count': 31, 'max_line_length': 708, 'avg_line_length': 77.90322580645162, 'alnum_prop': 0.7333333333333333, 'repo_name': 'resin-io-library/base-images', 'id': 'f8f424a03645f356b115ac1cb6fc878de0e39caf', 'size': '2436', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'balena-base-images/python/n310-tx2/fedora/34/3.10.2/build/Dockerfile', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Dockerfile', 'bytes': '71234697'}, {'name': 'JavaScript', 'bytes': '13096'}, {'name': 'Shell', 'bytes': '12051936'}, {'name': 'Smarty', 'bytes': '59789'}]} |
module SquareSpeechBalloon
class ApplicationController < ::ApplicationController
end
end
| {'content_hash': '8a47019d9b185b3c67d366ba4c808108', 'timestamp': '', 'source': 'github', 'line_count': 4, 'max_line_length': 55, 'avg_line_length': 23.25, 'alnum_prop': 0.8387096774193549, 'repo_name': 'yasushiito/square_speech_balloon', 'id': 'df561476e3456e9ca5ae56e4666848907fa1dcf6', 'size': '93', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'app/controllers/square_speech_balloon/application_controller.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '1064'}, {'name': 'CoffeeScript', 'bytes': '474'}, {'name': 'JavaScript', 'bytes': '599'}, {'name': 'Ruby', 'bytes': '11959'}]} |
<!DOCTYPE html>
<!--[if lt IE 7]> <html class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
<!--[if IE 7]> <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
<!--[if IE 8]> <html class="no-js lt-ie9"> <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js"> <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title></title>
<meta name="description" content="">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="/static/css/bootstrap.min.css">
<link rel="stylesheet" href="/static/css/pygments.css">
<style>
body {
padding-top: 60px;
padding-bottom: 40px;
}
</style>
<link rel="stylesheet" href="/static/css/bootstrap-responsive.min.css">
<link rel="stylesheet" href="/static/css/main.css">
<script src="/static/js/vendor/modernizr-2.6.2-respond-1.1.0.min.js"></script>
</head>
<body>
<!--[if lt IE 7]>
<p class="chromeframe">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> or <a href="http://www.google.com/chromeframe/?redirect=true">activate Google Chrome Frame</a> to improve your experience.</p>
<![endif]-->
<!-- This code is taken from http://twitter.github.com/bootstrap/examples/hero.html -->
<div class="container">
<div class="row-fluid">
<div class="span8 offset2">
{% block body %}
{% endblock body %}
</div>
</div>
</div> <!-- /container -->
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<script>window.jQuery || document.write('<script src="/static/js/vendor/jquery-1.9.1.min.js"><\/script>')</script>
<script src="/static/js/vendor/bootstrap.min.js"></script>
<script src="/static/js/plugins.js"></script>
<script src="/static/js/main.js"></script>
</body>
</html>
| {'content_hash': 'a42a95d3fb2e8e7f8e6c0ef7cf8d59bc', 'timestamp': '', 'source': 'github', 'line_count': 51, 'max_line_length': 279, 'avg_line_length': 42.666666666666664, 'alnum_prop': 0.5510110294117647, 'repo_name': 'chriskiehl/sandman', 'id': '9a62728fbdeaa74dbcc71ec3cd58a4045cfa08cc', 'size': '2176', 'binary': False, 'copies': '6', 'ref': 'refs/heads/develop', 'path': 'sandman/test/templates/base.html', 'mode': '33188', 'license': 'apache-2.0', 'language': []} |
package skype.utils;
import static skype.utils.FileStreamUtil.closeInputStream;
import java.io.File;
import java.nio.file.Path;
import skype.Main;
import skype.gui.popups.ErrorPopup;
/**
* The Class Config. This class holds all constants given from user in properties
* files.
*
* @author Thanasis Argyroudis
* @since 1.0
*/
//TODO: Make that class abstract and create subclass for each "config-family" of options. Eg. SPAM HANDLING config
public final class Config {
/** The Constant CONGIF_PATH. */
static final private String CONFIG_PATH;
/** The properties parser. */
private static PropertiesParser parser;
//------ SPAM HANDLING
/** Enable warnings. */
static public final boolean EnableWarnings;
/** Enable warnings for bot user. */
static public final boolean EnableSelfWarnings;
/** Interval between messages in order to increase warnings. */
static public final Long WarningInterval;
/** Action to take when warnings reach {@link #WarningNumber}. */
static public final int WarningAction;
/* Action that a spam (normal chat) handler can use */
/** Set to listener action */
static public final int WARNING_ACTION_SET_LISTENER = 2;
/** Kick from chat action */
static public final int WARNING_ACTION_KICK = 3;
/** kickban from chat action */
static public final int WARNING_ACTION_KICKBAN = 4;
/** The amount of warnings that is needed in order to take order. */
static public final int WarningNumber;
/** The minutes period that needs to pass in order to reset warnings. */
static public final int WarningResetTime;
//------ END SPAM
//------ COMMAND HANDLING
/** Enable commands for users. */
static public final boolean EnableUserCommands;
/** Maximum number of commands per day for users. */
static public final int MaximumNumberCommands;
/** Excluded users from using commands. */
static public final String[] ExcludedUsers;
/** Exclude commands. */
static public final String[] ExcludedCommands;
//------ END COMMANDS
//------ EDIT HANDLING
/** Enable edit tracking. */
static public final boolean EnableEdits;
/** Enable edit tracking for bot user. */
static public final boolean EnableSelfEdits;
/** Where you want original messages to be displayed */
static public final int EditOutput;
/* Methods that an edit handler can use to display edited messages */
/** Print original message in same chat which the edit happened */
static public final int EDIT_OUTPUT_SAME_CHAT = 1;
/** Print original message in the user's chat who made the edit */
static public final int EDIT_OUTPUT_PRIVATE_CHAT = 2;
/** Write original message to a file */
static public final int EDIT_OUTPUT_TO_FILE = 3;
/** Path of logger file for edits. */
static public final String EditPath;
//------ END EDITS
static { //Initiating all final values.
CONFIG_PATH = findConfigPath();
parser = new PropertiesParser(CONFIG_PATH);
EnableWarnings = Boolean.parseBoolean(parser.getProperty("EnableWarnings", "false"));
EnableSelfWarnings = Boolean.parseBoolean(parser.getProperty("EnableSelfWarnings", "false"));
EnableUserCommands = Boolean.parseBoolean(parser.getProperty("EnableUserCommands", "false"));
EnableEdits = Boolean.parseBoolean(parser.getProperty("EnableEdits", "false"));
EnableSelfEdits = Boolean.parseBoolean(parser.getProperty("EnableSelfEdits", "false"));
try {
Long.parseUnsignedLong(parser.getProperty("WarningInterval", "820"));
Byte.parseByte(parser.getProperty("WarningAction", "1"));
Integer.parseInt(parser.getProperty("WarningNumber", "1"));
Integer.parseInt(parser.getProperty("WarningReset", "10"));
Integer.parseInt(parser.getProperty("MaximumNumberCommands", "10"));
Byte.parseByte(parser.getProperty("EditOutput", "2"));
} catch (NumberFormatException e) {
new ErrorPopup("Invalid value " + e.getMessage().toLowerCase());
}
WarningInterval = Long.parseUnsignedLong(parser.getProperty("WarningInterval", "100"));
WarningAction = Byte.parseByte(parser.getProperty("WarningAction", "1"));
WarningNumber = Integer.parseInt(parser.getProperty("WarningNumber", "1"));
WarningResetTime = Integer.parseInt(parser.getProperty("WarningResetTime", "10"));
MaximumNumberCommands = Integer.parseInt(parser.getProperty("MaximumNumberCommands", "10"));
ExcludedUsers = parser.getProperty("ExcludedUsers", "").split(",");
ExcludedCommands = parser.getProperty("ExcludedCommands", "").split(",");
EditOutput = Byte.parseByte(parser.getProperty("EditOutput", "2"));
EditPath = parser.getProperty("EditPath", "");
if (EditPath.contains("//"))
EditPath.replaceAll("//", "////");
closeInputStream(parser.getInputStream());
}
/**
* The purpose of this method is just to execute the static block.
*/
public static void initate() {
}
/**
* No need of instances.
*/
private Config() {
}
/**
* Searches if the config file is at the same folder with jar. If not opens a
* file chooser and waits input from user.
*
* @return a string containing config path.
*/
private static final String findConfigPath() {
if (new File("Config.txt").exists())
return "Config.txt";
Path path = new ConfigFileChooser().showOpenDialog(Main.getMainFrame());
if (path == null) {
new ErrorPopup("Invalid file.");
}
return path.toString();
}
}
| {'content_hash': '0a7ce8c65153d802908157098d99e0d9', 'timestamp': '', 'source': 'github', 'line_count': 168, 'max_line_length': 114, 'avg_line_length': 31.714285714285715, 'alnum_prop': 0.7180930930930931, 'repo_name': 'Cuniq/SkypeBot', 'id': 'd941a527ddf6ebceaf0bfb3a7f03186679242221', 'size': '5929', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'src/skype/utils/Config.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '135570'}]} |
using System.Collections.Generic;
using System.Linq.Expressions;
using Handlebars.Core.Compiler.Lexer.Converter.BlockAccumulators;
namespace Handlebars.Core.Compiler.Lexer.Converter
{
internal class BlockAccumulator : ITokenConverter
{
private readonly HandlebarsConfiguration _configuration;
public BlockAccumulator(HandlebarsConfiguration configuration)
{
_configuration = configuration;
}
public IEnumerable<object> ConvertTokens(IEnumerable<object> sequence)
{
var enumerator = sequence.GetEnumerator();
while (enumerator.MoveNext())
{
var item = (Expression)enumerator.Current;
var context = BlockAccumulatorContext.Create(item, _configuration);
if (context != null)
{
yield return AccumulateBlock(enumerator, context);
}
else
{
yield return item;
}
}
}
private Expression AccumulateBlock(
IEnumerator<object> enumerator,
BlockAccumulatorContext context)
{
while (enumerator.MoveNext())
{
var item = (Expression)enumerator.Current;
var innerContext = BlockAccumulatorContext.Create(item, _configuration);
if (innerContext != null)
{
context.HandleElement(AccumulateBlock(enumerator, innerContext));
}
else if (context.IsClosingElement(item))
{
return context.GetAccumulatedBlock();
}
else
{
context.HandleElement(item);
}
}
throw new HandlebarsCompilerException(
$"Reached end of template before block expression '{context.Name}' was closed");
}
}
}
| {'content_hash': 'ee3d2aafc827df63fe800636ef139d73', 'timestamp': '', 'source': 'github', 'line_count': 60, 'max_line_length': 96, 'avg_line_length': 33.43333333333333, 'alnum_prop': 0.5438683948155534, 'repo_name': 'esskar/handlebars-core', 'id': '54c64458c245d349d7463dc3be79b23ae056b9ea', 'size': '2008', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'source/Handlebars.Core/Compiler/Lexer/Converter/BlockAccumulator.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C#', 'bytes': '291078'}]} |
<?php
namespace tests\Dudulina\CodeGeneration\Command\WriteSideEventHandlerDetectorTest;
use Dudulina\CodeGeneration\Command\WriteSideEventHandlerDetector;
use Dudulina\Event;
class WriteSideEventHandlerDetectorTest extends \PHPUnit_Framework_TestCase
{
public function testAccepted()
{
$commandClass = new \ReflectionClass(Event1::class);
$validatorClass = new \ReflectionClass(SomeValidReadModel::class);
$sut = new WriteSideEventHandlerDetector();
$this->assertTrue($sut->isMessageClass($commandClass));
$this->assertTrue($sut->isMethodAccepted($validatorClass->getMethods()[0]));
}
public function testNotAccepted()
{
$commandClass = new \ReflectionClass(\stdClass::class);
$validatorClass = new \ReflectionClass(SomeInvalidReadModel::class);
$sut = new WriteSideEventHandlerDetector();
$this->assertFalse($sut->isMessageClass($commandClass));
$this->assertFalse($sut->isMethodAccepted($validatorClass->getMethods()[0]));
}
}
class SomeValidReadModel
{
public function processEvent1(Event1 $command)
{
}
}
class Event1 implements Event
{
}
class SomeInvalidReadModel
{
public function doEvent1(Event1 $command)
{
}
}
| {'content_hash': 'da6007f06d2831b586a5b41c7cfae2db', 'timestamp': '', 'source': 'github', 'line_count': 57, 'max_line_length': 85, 'avg_line_length': 22.24561403508772, 'alnum_prop': 0.7089905362776026, 'repo_name': 'xprt64/cqrs-es', 'id': '6e255eac585af9d385276b5029dbc1e104548888', 'size': '1268', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'tests/Dudulina/Command/CodeAnalysis/WriteSideEventHandlerDetectorTest.php', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'PHP', 'bytes': '286245'}, {'name': 'Shell', 'bytes': '489'}]} |
import React from 'react'
import css from './Footer.scss'
export const Footer = () => {
return (
<div className={css.footer}>
<a href="https://github.com/LouisBarranqueiro/reapop#compatibility">Compatibility</a> -{' '}
<a href="https://github.com/LouisBarranqueiro/reapop#documentation">Documentation</a> -{' '}
<a href="https://github.com/LouisBarranqueiro/reapop">Source code</a>
</div>
)
}
export default Footer
| {'content_hash': '99f64881a2be25e0564453371bf868a6', 'timestamp': '', 'source': 'github', 'line_count': 14, 'max_line_length': 104, 'avg_line_length': 34.07142857142857, 'alnum_prop': 0.6289308176100629, 'repo_name': 'LouisBarranqueiro/reapop', 'id': 'b1a84c64ec531650c6cd638d55dedf98df32e3ec', 'size': '477', 'binary': False, 'copies': '1', 'ref': 'refs/heads/main', 'path': 'demo/src/components/Footer/Footer.tsx', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'JavaScript', 'bytes': '338'}, {'name': 'Shell', 'bytes': '58'}, {'name': 'TypeScript', 'bytes': '95204'}]} |
package org.drools.mvel.asm;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.drools.core.WorkingMemory;
import org.drools.core.common.InternalFactHandle;
import org.drools.core.reteoo.LeftTuple;
import org.drools.core.rule.Declaration;
import org.drools.core.rule.builder.dialect.asm.EvalStub;
import org.drools.mvel.asm.GeneratorHelper.DeclarationMatcher;
import org.drools.core.spi.CompiledInvoker;
import org.drools.core.spi.EvalExpression;
import org.drools.core.spi.Tuple;
import org.mvel2.asm.MethodVisitor;
import static org.drools.mvel.asm.GeneratorHelper.createInvokerClassGenerator;
import static org.drools.mvel.asm.GeneratorHelper.matchDeclarationsToTuple;
import static org.mvel2.asm.Opcodes.AALOAD;
import static org.mvel2.asm.Opcodes.ACC_PUBLIC;
import static org.mvel2.asm.Opcodes.ACONST_NULL;
import static org.mvel2.asm.Opcodes.ALOAD;
import static org.mvel2.asm.Opcodes.ARETURN;
import static org.mvel2.asm.Opcodes.ASTORE;
import static org.mvel2.asm.Opcodes.INVOKESTATIC;
import static org.mvel2.asm.Opcodes.IRETURN;
public class EvalGenerator {
private static final AtomicInteger evalId = new AtomicInteger();
public static void generate(final EvalStub stub ,
final Tuple tuple,
final Declaration[] declarations,
final WorkingMemory workingMemory) {
final String[] globals = stub.getGlobals();
final String[] globalTypes = stub.getGlobalTypes();
// Sort declarations based on their offset, so it can ascend the tuple's parents stack only once
final List<DeclarationMatcher> declarationMatchers = matchDeclarationsToTuple(declarations);
final ClassGenerator generator = createInvokerClassGenerator(stub, "_" + evalId.getAndIncrement(), workingMemory)
.setInterfaces(EvalExpression.class, CompiledInvoker.class);
generator.addMethod(ACC_PUBLIC, "createContext", generator.methodDescr(Object.class), new ClassGenerator.MethodBody() {
public void body(MethodVisitor mv) {
mv.visitInsn(ACONST_NULL);
mv.visitInsn(ARETURN);
}
}).addMethod(ACC_PUBLIC, "clone", generator.methodDescr(EvalExpression.class), new ClassGenerator.MethodBody() {
public void body(MethodVisitor mv) {
mv.visitVarInsn(ALOAD, 0);
mv.visitInsn(ARETURN);
}
}).addMethod(ACC_PUBLIC, "replaceDeclaration", generator.methodDescr(null, Declaration.class, Declaration.class)
).addMethod(ACC_PUBLIC, "evaluate", generator.methodDescr(Boolean.TYPE, Tuple.class, Declaration[].class, WorkingMemory.class, Object.class), new String[]{"java/lang/Exception"}, new GeneratorHelper.EvaluateMethod() {
public void body(MethodVisitor mv) {
objAstorePos = 7;
String[] expectedDeclarations = stub.getExpectedDeclarationTypes();
int[] declarationsParamsPos = new int[declarations.length];
mv.visitVarInsn(ALOAD, 1);
cast(LeftTuple.class);
mv.visitVarInsn(ASTORE, 5); // LeftTuple
Tuple currentTuple = tuple;
for (DeclarationMatcher matcher : declarationMatchers) {
int i = matcher.getMatcherIndex();
declarationsParamsPos[i] = objAstorePos;
currentTuple = traverseTuplesUntilDeclaration(currentTuple, matcher.getTupleIndex(), 5);
mv.visitVarInsn(ALOAD, 2);
push(i);
mv.visitInsn(AALOAD); // declarations[i]
mv.visitVarInsn(ALOAD, 3); // workingMemory
mv.visitVarInsn(ALOAD, 5);
invokeInterface(LeftTuple.class, "getFactHandle", InternalFactHandle.class);
invokeInterface(InternalFactHandle.class, "getObject", Object.class); // tuple.getFactHandle().getObject()
storeObjectFromDeclaration(declarations[i], expectedDeclarations[i]);
}
// @{ruleClassName}.@{methodName}(@foreach{declarations}, @foreach{globals})
StringBuilder evalMethodDescr = new StringBuilder("(");
for (int i = 0; i < declarations.length; i++) {
load(declarationsParamsPos[i]); // declarations[i]
evalMethodDescr.append(typeDescr(expectedDeclarations[i]));
}
// @foreach{type : globalTypes, identifier : globals} @{type} @{identifier} = ( @{type} ) workingMemory.getGlobal( "@{identifier}" );
parseGlobals(globals, globalTypes, 3, evalMethodDescr);
evalMethodDescr.append(")Z");
mv.visitMethodInsn(INVOKESTATIC, stub.getInternalRuleClassName(), stub.getMethodName(), evalMethodDescr.toString());
mv.visitInsn(IRETURN);
}
});
stub.setEval(generator.<EvalExpression>newInstance());
}
}
| {'content_hash': '5ecaf4aeecea069492c0d21f471a52cc', 'timestamp': '', 'source': 'github', 'line_count': 107, 'max_line_length': 225, 'avg_line_length': 47.4392523364486, 'alnum_prop': 0.6544523246650906, 'repo_name': 'jomarko/drools', 'id': '451b414fb60eb0aa29fb91e2953762547d934d1d', 'size': '5656', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'drools-mvel/src/main/java/org/drools/mvel/asm/EvalGenerator.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'ANTLR', 'bytes': '16820'}, {'name': 'ASL', 'bytes': '9582'}, {'name': 'Batchfile', 'bytes': '2554'}, {'name': 'CSS', 'bytes': '1969'}, {'name': 'GAP', 'bytes': '198103'}, {'name': 'HTML', 'bytes': '8245'}, {'name': 'Java', 'bytes': '42823510'}, {'name': 'Python', 'bytes': '4555'}, {'name': 'Ruby', 'bytes': '491'}, {'name': 'Shell', 'bytes': '1120'}, {'name': 'XSLT', 'bytes': '24302'}]} |
using Mvc5DI.Controllers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace Mvc5DI.Infrastructure
{
public class MyResolver : System.Web.Mvc.IDependencyResolver
{
public object GetService(Type serviceType)
{
if (serviceType == typeof(CustomerController))
{
var customerSvc = new Services.CustomerService();
var controller = new Controllers.CustomerController(customerSvc);
return controller;
}
return null;
}
public IEnumerable<object> GetServices(Type serviceType)
{
return new List<object>();
}
}
} | {'content_hash': '0d5cd96c3bbf8141128c80535a72ba9c', 'timestamp': '', 'source': 'github', 'line_count': 27, 'max_line_length': 81, 'avg_line_length': 27.48148148148148, 'alnum_prop': 0.5876010781671159, 'repo_name': 'huanlin/Examples', 'id': '6050bfd00e53dc96b1dcb955f70bde9581cbf4c4', 'size': '744', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'DotNet/Web/MVC/Mvc5DI/Mvc5DI/Infrastructure/MyResolver.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'ASP.NET', 'bytes': '7864'}, {'name': 'C', 'bytes': '7229'}, {'name': 'C#', 'bytes': '815053'}, {'name': 'C++', 'bytes': '360577'}, {'name': 'CSS', 'bytes': '27580'}, {'name': 'HTML', 'bytes': '65651'}, {'name': 'JavaScript', 'bytes': '4859624'}, {'name': 'Pascal', 'bytes': '38856'}, {'name': 'Pawn', 'bytes': '911'}, {'name': 'PowerShell', 'bytes': '846'}, {'name': 'QMake', 'bytes': '7744'}, {'name': 'Ruby', 'bytes': '5958'}, {'name': 'VBA', 'bytes': '5920'}]} |
.layout-file-text .exhibit-items {
max-width: 40%;
}
.layout-file-text .exhibit-items > * {
max-width: 100%;
margin-bottom: 1em;
}
.layout-file-text .exhibit-items > *:last-child {
margin-bottom: 0;
}
.layout-file-text .exhibit-items .download-file {
clear: both;
border-bottom: 0;
overflow: visible;
}
.layout-file-text .exhibit-items.left {
float: left;
margin-right: 2%;
margin-left: 0;
}
.layout-file-text .exhibit-items.right {
float: right;
margin-left: 2%;
margin-right: 0;
}
.layout-file-text .exhibit-items .fullsize img {
max-width: 100%;
margin-bottom: 1em;
}
.layout-file-text .exhibit-item-caption p {
margin: 0;
clear: both;
}
.layout-file-text .captions-center .exhibit-item-caption {
text-align: center;
}
.layout-file-text .captions-left .exhibit-item-caption {
text-align: left;
}
.layout-file-text .captions-right .exhibit-item-caption {
text-align: right;
} | {'content_hash': '9be807aa88e3d9ee386bc0bafa892c32', 'timestamp': '', 'source': 'github', 'line_count': 52, 'max_line_length': 58, 'avg_line_length': 18.596153846153847, 'alnum_prop': 0.6473629782833505, 'repo_name': 'jbfink/docker-omeka', 'id': '99de4c824019fc95b80c77b72e67157dfa436328', 'size': '967', 'binary': False, 'copies': '30', 'ref': 'refs/heads/master', 'path': 'omeka/omeka-2.4.1/plugins/ExhibitBuilder/views/shared/exhibit_layouts/file-text/layout.css', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'ApacheConf', 'bytes': '1702'}, {'name': 'Batchfile', 'bytes': '1036'}, {'name': 'CSS', 'bytes': '353082'}, {'name': 'HTML', 'bytes': '4259'}, {'name': 'JavaScript', 'bytes': '82133'}, {'name': 'PHP', 'bytes': '19884720'}, {'name': 'PowerShell', 'bytes': '1028'}, {'name': 'Shell', 'bytes': '727'}, {'name': 'XSLT', 'bytes': '6298'}]} |
using content::BrowserThread;
namespace atom {
namespace {
const char kRootName[] = "<root>";
struct FileSystem {
FileSystem() {}
FileSystem(const std::string& file_system_name,
const std::string& root_url,
const std::string& file_system_path)
: file_system_name(file_system_name),
root_url(root_url),
file_system_path(file_system_path) {}
std::string file_system_name;
std::string root_url;
std::string file_system_path;
};
std::string RegisterFileSystem(content::WebContents* web_contents,
const base::FilePath& path) {
auto* isolated_context = storage::IsolatedContext::GetInstance();
std::string root_name(kRootName);
std::string file_system_id = isolated_context->RegisterFileSystemForPath(
storage::kFileSystemTypeNativeLocal, std::string(), path, &root_name);
content::ChildProcessSecurityPolicy* policy =
content::ChildProcessSecurityPolicy::GetInstance();
content::RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
int renderer_id = render_view_host->GetProcess()->GetID();
policy->GrantReadFileSystem(renderer_id, file_system_id);
policy->GrantWriteFileSystem(renderer_id, file_system_id);
policy->GrantCreateFileForFileSystem(renderer_id, file_system_id);
policy->GrantDeleteFromFileSystem(renderer_id, file_system_id);
if (!policy->CanReadFile(renderer_id, path))
policy->GrantReadFile(renderer_id, path);
return file_system_id;
}
FileSystem CreateFileSystemStruct(content::WebContents* web_contents,
const std::string& file_system_id,
const std::string& file_system_path) {
const GURL origin = web_contents->GetURL().GetOrigin();
std::string file_system_name =
storage::GetIsolatedFileSystemName(origin, file_system_id);
std::string root_url = storage::GetIsolatedFileSystemRootURIString(
origin, file_system_id, kRootName);
return FileSystem(file_system_name, root_url, file_system_path);
}
std::unique_ptr<base::DictionaryValue> CreateFileSystemValue(
const FileSystem& file_system) {
std::unique_ptr<base::DictionaryValue> file_system_value(
new base::DictionaryValue());
file_system_value->SetString("fileSystemName", file_system.file_system_name);
file_system_value->SetString("rootURL", file_system.root_url);
file_system_value->SetString("fileSystemPath", file_system.file_system_path);
return file_system_value;
}
void WriteToFile(const base::FilePath& path, const std::string& content) {
base::AssertBlockingAllowed();
DCHECK(!path.empty());
base::WriteFile(path, content.data(), content.size());
}
void AppendToFile(const base::FilePath& path, const std::string& content) {
base::AssertBlockingAllowed();
DCHECK(!path.empty());
base::AppendToFile(path, content.data(), content.size());
}
PrefService* GetPrefService(content::WebContents* web_contents) {
auto* context = web_contents->GetBrowserContext();
return static_cast<atom::AtomBrowserContext*>(context)->prefs();
}
std::set<std::string> GetAddedFileSystemPaths(
content::WebContents* web_contents) {
auto* pref_service = GetPrefService(web_contents);
const base::DictionaryValue* file_system_paths_value =
pref_service->GetDictionary(prefs::kDevToolsFileSystemPaths);
std::set<std::string> result;
if (file_system_paths_value) {
base::DictionaryValue::Iterator it(*file_system_paths_value);
for (; !it.IsAtEnd(); it.Advance()) {
result.insert(it.key());
}
}
return result;
}
bool IsDevToolsFileSystemAdded(content::WebContents* web_contents,
const std::string& file_system_path) {
auto file_system_paths = GetAddedFileSystemPaths(web_contents);
return file_system_paths.find(file_system_path) != file_system_paths.end();
}
} // namespace
CommonWebContentsDelegate::CommonWebContentsDelegate()
: devtools_file_system_indexer_(new DevToolsFileSystemIndexer),
file_task_runner_(
base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()})) {}
CommonWebContentsDelegate::~CommonWebContentsDelegate() {}
void CommonWebContentsDelegate::InitWithWebContents(
content::WebContents* web_contents,
AtomBrowserContext* browser_context,
bool is_guest) {
browser_context_ = browser_context;
web_contents->SetDelegate(this);
printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
printing::PrintPreviewMessageHandler::CreateForWebContents(web_contents);
// Determien whether the WebContents is offscreen.
auto* web_preferences = WebContentsPreferences::From(web_contents);
offscreen_ =
!web_preferences || web_preferences->IsEnabled(options::kOffscreen);
// Create InspectableWebContents.
web_contents_.reset(
brightray::InspectableWebContents::Create(web_contents, is_guest));
web_contents_->SetDelegate(this);
}
void CommonWebContentsDelegate::SetOwnerWindow(NativeWindow* owner_window) {
SetOwnerWindow(GetWebContents(), owner_window);
}
void CommonWebContentsDelegate::SetOwnerWindow(
content::WebContents* web_contents,
NativeWindow* owner_window) {
owner_window_ = owner_window ? owner_window->GetWeakPtr() : nullptr;
auto relay = std::make_unique<NativeWindowRelay>(owner_window_);
auto* relay_key = relay->key;
if (owner_window) {
#if defined(TOOLKIT_VIEWS) && !defined(OS_MACOSX)
autofill_popup_.reset(new AutofillPopup());
#endif
web_contents->SetUserData(relay_key, std::move(relay));
} else {
web_contents->RemoveUserData(relay_key);
relay.reset();
}
}
void CommonWebContentsDelegate::ResetManagedWebContents(bool async) {
if (async) {
base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
web_contents_.release());
} else {
web_contents_.reset();
}
}
content::WebContents* CommonWebContentsDelegate::GetWebContents() const {
if (!web_contents_)
return nullptr;
return web_contents_->GetWebContents();
}
content::WebContents* CommonWebContentsDelegate::GetDevToolsWebContents()
const {
if (!web_contents_)
return nullptr;
return web_contents_->GetDevToolsWebContents();
}
content::WebContents* CommonWebContentsDelegate::OpenURLFromTab(
content::WebContents* source,
const content::OpenURLParams& params) {
content::NavigationController::LoadURLParams load_url_params(params.url);
load_url_params.referrer = params.referrer;
load_url_params.transition_type = params.transition;
load_url_params.extra_headers = params.extra_headers;
load_url_params.should_replace_current_entry =
params.should_replace_current_entry;
load_url_params.is_renderer_initiated = params.is_renderer_initiated;
load_url_params.should_clear_history_list = true;
source->GetController().LoadURLWithParams(load_url_params);
return source;
}
bool CommonWebContentsDelegate::CanOverscrollContent() const {
return false;
}
content::ColorChooser* CommonWebContentsDelegate::OpenColorChooser(
content::WebContents* web_contents,
SkColor color,
const std::vector<blink::mojom::ColorSuggestionPtr>& suggestions) {
return chrome::ShowColorChooser(web_contents, color);
}
void CommonWebContentsDelegate::RunFileChooser(
content::RenderFrameHost* render_frame_host,
const content::FileChooserParams& params) {
if (!web_dialog_helper_)
web_dialog_helper_.reset(new WebDialogHelper(owner_window(), offscreen_));
web_dialog_helper_->RunFileChooser(render_frame_host, params);
}
void CommonWebContentsDelegate::EnumerateDirectory(content::WebContents* guest,
int request_id,
const base::FilePath& path) {
if (!web_dialog_helper_)
web_dialog_helper_.reset(new WebDialogHelper(owner_window(), offscreen_));
web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
}
void CommonWebContentsDelegate::EnterFullscreenModeForTab(
content::WebContents* source,
const GURL& origin) {
if (!owner_window_)
return;
SetHtmlApiFullscreen(true);
owner_window_->NotifyWindowEnterHtmlFullScreen();
source->GetRenderViewHost()->GetWidget()->WasResized();
}
void CommonWebContentsDelegate::ExitFullscreenModeForTab(
content::WebContents* source) {
if (!owner_window_)
return;
SetHtmlApiFullscreen(false);
owner_window_->NotifyWindowLeaveHtmlFullScreen();
source->GetRenderViewHost()->GetWidget()->WasResized();
}
bool CommonWebContentsDelegate::IsFullscreenForTabOrPending(
const content::WebContents* source) const {
return html_fullscreen_;
}
blink::WebSecurityStyle CommonWebContentsDelegate::GetSecurityStyle(
content::WebContents* web_contents,
content::SecurityStyleExplanations* security_style_explanations) {
SecurityStateTabHelper* helper =
SecurityStateTabHelper::FromWebContents(web_contents);
DCHECK(helper);
security_state::SecurityInfo security_info;
helper->GetSecurityInfo(&security_info);
return security_state::GetSecurityStyle(security_info,
security_style_explanations);
}
void CommonWebContentsDelegate::DevToolsSaveToFile(const std::string& url,
const std::string& content,
bool save_as) {
base::FilePath path;
auto it = saved_files_.find(url);
if (it != saved_files_.end() && !save_as) {
path = it->second;
} else {
file_dialog::DialogSettings settings;
settings.parent_window = owner_window();
settings.force_detached = offscreen_;
settings.title = url;
settings.default_path = base::FilePath::FromUTF8Unsafe(url);
if (!file_dialog::ShowSaveDialog(settings, &path)) {
base::Value url_value(url);
web_contents_->CallClientFunction("DevToolsAPI.canceledSaveURL",
&url_value, nullptr, nullptr);
return;
}
}
saved_files_[url] = path;
// Notify DevTools.
base::Value url_value(url);
base::Value file_system_path_value(path.AsUTF8Unsafe());
web_contents_->CallClientFunction("DevToolsAPI.savedURL", &url_value,
&file_system_path_value, nullptr);
file_task_runner_->PostTask(FROM_HERE,
base::BindOnce(&WriteToFile, path, content));
}
void CommonWebContentsDelegate::DevToolsAppendToFile(
const std::string& url,
const std::string& content) {
auto it = saved_files_.find(url);
if (it == saved_files_.end())
return;
// Notify DevTools.
base::Value url_value(url);
web_contents_->CallClientFunction("DevToolsAPI.appendedToURL", &url_value,
nullptr, nullptr);
file_task_runner_->PostTask(
FROM_HERE, base::BindOnce(&AppendToFile, it->second, content));
}
void CommonWebContentsDelegate::DevToolsRequestFileSystems() {
auto file_system_paths = GetAddedFileSystemPaths(GetDevToolsWebContents());
if (file_system_paths.empty()) {
base::ListValue empty_file_system_value;
web_contents_->CallClientFunction("DevToolsAPI.fileSystemsLoaded",
&empty_file_system_value, nullptr,
nullptr);
return;
}
std::vector<FileSystem> file_systems;
for (const auto& file_system_path : file_system_paths) {
base::FilePath path = base::FilePath::FromUTF8Unsafe(file_system_path);
std::string file_system_id =
RegisterFileSystem(GetDevToolsWebContents(), path);
FileSystem file_system = CreateFileSystemStruct(
GetDevToolsWebContents(), file_system_id, file_system_path);
file_systems.push_back(file_system);
}
base::ListValue file_system_value;
for (const auto& file_system : file_systems)
file_system_value.Append(CreateFileSystemValue(file_system));
web_contents_->CallClientFunction("DevToolsAPI.fileSystemsLoaded",
&file_system_value, nullptr, nullptr);
}
void CommonWebContentsDelegate::DevToolsAddFileSystem(
const base::FilePath& file_system_path) {
base::FilePath path = file_system_path;
if (path.empty()) {
std::vector<base::FilePath> paths;
file_dialog::DialogSettings settings;
settings.parent_window = owner_window();
settings.force_detached = offscreen_;
settings.properties = file_dialog::FILE_DIALOG_OPEN_DIRECTORY;
if (!file_dialog::ShowOpenDialog(settings, &paths))
return;
path = paths[0];
}
std::string file_system_id =
RegisterFileSystem(GetDevToolsWebContents(), path);
if (IsDevToolsFileSystemAdded(GetDevToolsWebContents(), path.AsUTF8Unsafe()))
return;
FileSystem file_system = CreateFileSystemStruct(
GetDevToolsWebContents(), file_system_id, path.AsUTF8Unsafe());
std::unique_ptr<base::DictionaryValue> file_system_value(
CreateFileSystemValue(file_system));
auto* pref_service = GetPrefService(GetDevToolsWebContents());
DictionaryPrefUpdate update(pref_service, prefs::kDevToolsFileSystemPaths);
update.Get()->SetWithoutPathExpansion(path.AsUTF8Unsafe(),
std::make_unique<base::Value>());
web_contents_->CallClientFunction("DevToolsAPI.fileSystemAdded",
file_system_value.get(), nullptr, nullptr);
}
void CommonWebContentsDelegate::DevToolsRemoveFileSystem(
const base::FilePath& file_system_path) {
if (!web_contents_)
return;
std::string path = file_system_path.AsUTF8Unsafe();
storage::IsolatedContext::GetInstance()->RevokeFileSystemByPath(
file_system_path);
auto* pref_service = GetPrefService(GetDevToolsWebContents());
DictionaryPrefUpdate update(pref_service, prefs::kDevToolsFileSystemPaths);
update.Get()->RemoveWithoutPathExpansion(path, nullptr);
base::Value file_system_path_value(path);
web_contents_->CallClientFunction("DevToolsAPI.fileSystemRemoved",
&file_system_path_value, nullptr, nullptr);
}
void CommonWebContentsDelegate::DevToolsIndexPath(
int request_id,
const std::string& file_system_path) {
if (!IsDevToolsFileSystemAdded(GetDevToolsWebContents(), file_system_path)) {
OnDevToolsIndexingDone(request_id, file_system_path);
return;
}
if (devtools_indexing_jobs_.count(request_id) != 0)
return;
devtools_indexing_jobs_[request_id] =
scoped_refptr<DevToolsFileSystemIndexer::FileSystemIndexingJob>(
devtools_file_system_indexer_->IndexPath(
file_system_path,
base::Bind(
&CommonWebContentsDelegate::OnDevToolsIndexingWorkCalculated,
base::Unretained(this), request_id, file_system_path),
base::Bind(&CommonWebContentsDelegate::OnDevToolsIndexingWorked,
base::Unretained(this), request_id, file_system_path),
base::Bind(&CommonWebContentsDelegate::OnDevToolsIndexingDone,
base::Unretained(this), request_id,
file_system_path)));
}
void CommonWebContentsDelegate::DevToolsStopIndexing(int request_id) {
auto it = devtools_indexing_jobs_.find(request_id);
if (it == devtools_indexing_jobs_.end())
return;
it->second->Stop();
devtools_indexing_jobs_.erase(it);
}
void CommonWebContentsDelegate::DevToolsSearchInPath(
int request_id,
const std::string& file_system_path,
const std::string& query) {
if (!IsDevToolsFileSystemAdded(GetDevToolsWebContents(), file_system_path)) {
OnDevToolsSearchCompleted(request_id, file_system_path,
std::vector<std::string>());
return;
}
devtools_file_system_indexer_->SearchInPath(
file_system_path, query,
base::Bind(&CommonWebContentsDelegate::OnDevToolsSearchCompleted,
base::Unretained(this), request_id, file_system_path));
}
void CommonWebContentsDelegate::OnDevToolsIndexingWorkCalculated(
int request_id,
const std::string& file_system_path,
int total_work) {
base::Value request_id_value(request_id);
base::Value file_system_path_value(file_system_path);
base::Value total_work_value(total_work);
web_contents_->CallClientFunction("DevToolsAPI.indexingTotalWorkCalculated",
&request_id_value, &file_system_path_value,
&total_work_value);
}
void CommonWebContentsDelegate::OnDevToolsIndexingWorked(
int request_id,
const std::string& file_system_path,
int worked) {
base::Value request_id_value(request_id);
base::Value file_system_path_value(file_system_path);
base::Value worked_value(worked);
web_contents_->CallClientFunction("DevToolsAPI.indexingWorked",
&request_id_value, &file_system_path_value,
&worked_value);
}
void CommonWebContentsDelegate::OnDevToolsIndexingDone(
int request_id,
const std::string& file_system_path) {
devtools_indexing_jobs_.erase(request_id);
base::Value request_id_value(request_id);
base::Value file_system_path_value(file_system_path);
web_contents_->CallClientFunction("DevToolsAPI.indexingDone",
&request_id_value, &file_system_path_value,
nullptr);
}
void CommonWebContentsDelegate::OnDevToolsSearchCompleted(
int request_id,
const std::string& file_system_path,
const std::vector<std::string>& file_paths) {
base::ListValue file_paths_value;
for (const auto& file_path : file_paths) {
file_paths_value.AppendString(file_path);
}
base::Value request_id_value(request_id);
base::Value file_system_path_value(file_system_path);
web_contents_->CallClientFunction("DevToolsAPI.searchCompleted",
&request_id_value, &file_system_path_value,
&file_paths_value);
}
void CommonWebContentsDelegate::SetHtmlApiFullscreen(bool enter_fullscreen) {
// Window is already in fullscreen mode, save the state.
if (enter_fullscreen && owner_window_->IsFullscreen()) {
native_fullscreen_ = true;
html_fullscreen_ = true;
return;
}
// Exit html fullscreen state but not window's fullscreen mode.
if (!enter_fullscreen && native_fullscreen_) {
html_fullscreen_ = false;
return;
}
owner_window_->SetFullScreen(enter_fullscreen);
html_fullscreen_ = enter_fullscreen;
native_fullscreen_ = false;
}
} // namespace atom
| {'content_hash': '7231d81c2fab9f80b7da053319900143', 'timestamp': '', 'source': 'github', 'line_count': 498, 'max_line_length': 80, 'avg_line_length': 37.381526104417674, 'alnum_prop': 0.6874731413837559, 'repo_name': 'shiftkey/electron', 'id': 'b3b1195e044cd2c74b246aa13e9e85953d694477', 'size': '20251', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'atom/browser/common_web_contents_delegate.cc', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '3717'}, {'name': 'C++', 'bytes': '2869366'}, {'name': 'CSS', 'bytes': '2379'}, {'name': 'Dockerfile', 'bytes': '513'}, {'name': 'HTML', 'bytes': '14861'}, {'name': 'JavaScript', 'bytes': '978617'}, {'name': 'Objective-C', 'bytes': '60282'}, {'name': 'Objective-C++', 'bytes': '354967'}, {'name': 'PowerShell', 'bytes': '99'}, {'name': 'Python', 'bytes': '310407'}, {'name': 'Shell', 'bytes': '13803'}]} |
package org.apache.hadoop.hdfs.server.protocol;
import org.apache.hadoop.hdfs.StorageType;
import java.util.UUID;
/**
* Class captures information of a storage in Datanode.
*/
public class DatanodeStorage {
/** The state of the storage. */
public enum State {
NORMAL,
/**
* A storage that represents a read-only path to replicas stored on a shared storage device.
* Replicas on {@link #READ_ONLY_SHARED} storage are not counted towards live replicas.
*
* <p>
* In certain implementations, a {@link #READ_ONLY_SHARED} storage may be correlated to
* its {@link #NORMAL} counterpart using the {@link DatanodeStorage#storageID}. This
* property should be used for debugging purposes only.
* </p>
*/
READ_ONLY_SHARED;
}
private final String storageID;
private final State state;
private final StorageType storageType;
/**
* Create a storage with {@link State#NORMAL} and {@link StorageType#DEFAULT}.
*
* @param storageID
*/
public DatanodeStorage(String storageID) {
this(storageID, State.NORMAL, StorageType.DEFAULT);
}
public DatanodeStorage(String sid, State s, StorageType sm) {
this.storageID = sid;
this.state = s;
this.storageType = sm;
}
public String getStorageID() {
return storageID;
}
public State getState() {
return state;
}
public StorageType getStorageType() {
return storageType;
}
/**
* Generate new storage ID. The format of this string can be changed
* in the future without requiring that old storage IDs be updated.
*
* @return unique storage ID
*/
public static String generateUuid() {
return "DS-" + UUID.randomUUID();
}
@Override
public boolean equals(Object other){
if (other == this) {
return true;
}
if ((other == null) ||
!(other instanceof DatanodeStorage)) {
return false;
}
DatanodeStorage otherStorage = (DatanodeStorage) other;
return otherStorage.getStorageID().compareTo(getStorageID()) == 0;
}
@Override
public int hashCode() {
return getStorageID().hashCode();
}
}
| {'content_hash': 'b28caaddb9877f2dab7c8a45a2e07f1c', 'timestamp': '', 'source': 'github', 'line_count': 88, 'max_line_length': 96, 'avg_line_length': 24.329545454545453, 'alnum_prop': 0.6623073330219523, 'repo_name': 'srijeyanthan/hadoop_2_4_0_experimental_version', 'id': '09675cdf3f341bc78648923a80298f896df7a9a9', 'size': '2947', 'binary': False, 'copies': '5', 'ref': 'refs/heads/master', 'path': 'hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/protocol/DatanodeStorage.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'AspectJ', 'bytes': '31146'}, {'name': 'Batchfile', 'bytes': '62331'}, {'name': 'C', 'bytes': '1107777'}, {'name': 'C++', 'bytes': '81364'}, {'name': 'CMake', 'bytes': '33293'}, {'name': 'CSS', 'bytes': '43086'}, {'name': 'HTML', 'bytes': '2049063'}, {'name': 'Java', 'bytes': '40082459'}, {'name': 'JavaScript', 'bytes': '20449'}, {'name': 'Perl', 'bytes': '18992'}, {'name': 'Protocol Buffer', 'bytes': '187832'}, {'name': 'Python', 'bytes': '37348'}, {'name': 'Shell', 'bytes': '237386'}, {'name': 'TeX', 'bytes': '19322'}, {'name': 'XSLT', 'bytes': '36122'}]} |
package org.jbpm.services.api.model;
import java.util.List;
import java.util.Map;
public interface ProcessDesc extends DeployedAsset {
String getPackageName();
String getNamespace();
String getDeploymentId();
String getEncodedProcessSource();
Map<String, String> getForms();
List<String> getRoles();
}
| {'content_hash': '0f8d2ed79a2067ac334acecf0e685bef', 'timestamp': '', 'source': 'github', 'line_count': 21, 'max_line_length': 52, 'avg_line_length': 15.142857142857142, 'alnum_prop': 0.7547169811320755, 'repo_name': 'domhanak/jbpm', 'id': '3691bda19bc895e1d99b7bb4ec750408833ecaa4', 'size': '937', 'binary': False, 'copies': '3', 'ref': 'refs/heads/master', 'path': 'jbpm-services/jbpm-services-api/src/main/java/org/jbpm/services/api/model/ProcessDesc.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'FreeMarker', 'bytes': '24447'}, {'name': 'HTML', 'bytes': '271'}, {'name': 'Java', 'bytes': '14344879'}, {'name': 'PLSQL', 'bytes': '34719'}, {'name': 'PLpgSQL', 'bytes': '11997'}, {'name': 'Protocol Buffer', 'bytes': '6518'}, {'name': 'Shell', 'bytes': '98'}, {'name': 'Visual Basic', 'bytes': '2545'}]} |
/**
* Autogenerated by Thrift
*
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
* @generated
*/
package com.facebook.thrift.annotation_deprecated;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.BitSet;
import java.util.Arrays;
import com.facebook.thrift.*;
import com.facebook.thrift.annotations.*;
import com.facebook.thrift.async.*;
import com.facebook.thrift.meta_data.*;
import com.facebook.thrift.server.*;
import com.facebook.thrift.transport.*;
import com.facebook.thrift.protocol.*;
/**
* Field declartaions, for example in `struct` or `function` declartions.
*/
@SuppressWarnings({ "unused", "serial" })
public class Field implements TBase, java.io.Serializable, Cloneable, Comparable<Field> {
private static final TStruct STRUCT_DESC = new TStruct("Field");
public static final Map<Integer, FieldMetaData> metaDataMap;
static {
Map<Integer, FieldMetaData> tmpMetaDataMap = new HashMap<Integer, FieldMetaData>();
metaDataMap = Collections.unmodifiableMap(tmpMetaDataMap);
}
static {
FieldMetaData.addStructMetaDataMap(Field.class, metaDataMap);
}
public Field() {
}
public static class Builder {
public Builder() {
}
public Field build() {
Field result = new Field();
return result;
}
}
public static Builder builder() {
return new Builder();
}
/**
* Performs a deep copy on <i>other</i>.
*/
public Field(Field other) {
}
public Field deepCopy() {
return new Field(this);
}
public void setFieldValue(int fieldID, Object __value) {
switch (fieldID) {
default:
throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
}
}
public Object getFieldValue(int fieldID) {
switch (fieldID) {
default:
throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
}
}
@Override
public boolean equals(Object _that) {
if (_that == null)
return false;
if (this == _that)
return true;
if (!(_that instanceof Field))
return false;
Field that = (Field)_that;
return true;
}
@Override
public int hashCode() {
return Arrays.deepHashCode(new Object[] {});
}
@Override
public int compareTo(Field other) {
if (other == null) {
// See java.lang.Comparable docs
throw new NullPointerException();
}
if (other == this) {
return 0;
}
int lastComparison = 0;
return 0;
}
public void read(TProtocol iprot) throws TException {
TField __field;
iprot.readStructBegin(metaDataMap);
while (true)
{
__field = iprot.readFieldBegin();
if (__field.type == TType.STOP) {
break;
}
switch (__field.id)
{
default:
TProtocolUtil.skip(iprot, __field.type);
break;
}
iprot.readFieldEnd();
}
iprot.readStructEnd();
// check for required fields of primitive type, which can't be checked in the validate method
validate();
}
public void write(TProtocol oprot) throws TException {
validate();
oprot.writeStructBegin(STRUCT_DESC);
oprot.writeFieldStop();
oprot.writeStructEnd();
}
@Override
public String toString() {
return toString(1, true);
}
@Override
public String toString(int indent, boolean prettyPrint) {
String indentStr = prettyPrint ? TBaseHelper.getIndentedString(indent) : "";
String newLine = prettyPrint ? "\n" : "";
String space = prettyPrint ? " " : "";
StringBuilder sb = new StringBuilder("Field");
sb.append(space);
sb.append("(");
sb.append(newLine);
boolean first = true;
sb.append(newLine + TBaseHelper.reduceIndent(indentStr));
sb.append(")");
return sb.toString();
}
public void validate() throws TException {
// check for required fields
}
}
| {'content_hash': 'c56fb1fdc17fd29259ba24f26bce4c7b', 'timestamp': '', 'source': 'github', 'line_count': 177, 'max_line_length': 97, 'avg_line_length': 22.610169491525422, 'alnum_prop': 0.6519240379810095, 'repo_name': 'facebook/fbthrift', 'id': '7ed69aa23b52fe2a493a93f1998fe76873e5c12d', 'size': '4002', 'binary': False, 'copies': '10', 'ref': 'refs/heads/main', 'path': 'thrift/compiler/test/fixtures/enums/gen-javadeprecated/com/facebook/thrift/annotation_deprecated/Field.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'C', 'bytes': '15608'}, {'name': 'C++', 'bytes': '10658844'}, {'name': 'CMake', 'bytes': '147347'}, {'name': 'CSS', 'bytes': '4028'}, {'name': 'Cython', 'bytes': '339005'}, {'name': 'Emacs Lisp', 'bytes': '11229'}, {'name': 'Go', 'bytes': '447092'}, {'name': 'Hack', 'bytes': '313122'}, {'name': 'Java', 'bytes': '1990062'}, {'name': 'JavaScript', 'bytes': '38872'}, {'name': 'Mustache', 'bytes': '1269560'}, {'name': 'Python', 'bytes': '1623026'}, {'name': 'Ruby', 'bytes': '6111'}, {'name': 'Rust', 'bytes': '283392'}, {'name': 'Shell', 'bytes': '6615'}, {'name': 'Thrift', 'bytes': '1859041'}, {'name': 'Vim Script', 'bytes': '2887'}]} |
Refinery::Plugin.register do |plugin|
plugin.title = "Testimonials"
plugin.description = "Manage Testimonials"
plugin.url = "/admin/#{plugin.title.downcase}"
plugin.version = 1.0
plugin.activity = {:class => Testimonial, :url_prefix => "edit_", :title => 'quote'}
end
require File.dirname(__FILE__) + '/../lib/refinery_testimonials'
| {'content_hash': 'ff4b81b4ee57d3311d112fcfad58602e', 'timestamp': '', 'source': 'github', 'line_count': 9, 'max_line_length': 86, 'avg_line_length': 38.22222222222222, 'alnum_prop': 0.688953488372093, 'repo_name': 'chrise86/refinerycms-testimonials', 'id': '905c3365ac29ec36236be0efd8d0d3d7f480b564', 'size': '344', 'binary': False, 'copies': '5', 'ref': 'refs/heads/master', 'path': 'rails/init.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '2438'}, {'name': 'HTML', 'bytes': '12432'}, {'name': 'JavaScript', 'bytes': '975'}, {'name': 'Ruby', 'bytes': '68947'}]} |
package jianshu.datalab.xin.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* Created by bonismo
* 下午9:44 on 16/3/8.
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{
private Integer id;
private String nick;
private String mobile;
private String password;
private String avatar;
private int pay;
private double money;
private String lastIp;
private String lastTime;
private String signUpTime;
public User(String nick, String mobile, String password, String lastIp) {
this.nick = nick;
this.mobile = mobile;
this.password = password;
this.lastIp = lastIp;
}
}
| {'content_hash': '0264664e3c25bc526e2361d0744a50b9', 'timestamp': '', 'source': 'github', 'line_count': 34, 'max_line_length': 77, 'avg_line_length': 22.61764705882353, 'alnum_prop': 0.7009102730819246, 'repo_name': 'StayHungryStayFoolish/stayhungrystayfoolish.github.com', 'id': '1182f834ff33c9b8b280cfc489132372bb7cc526', 'size': '773', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'Jian_Shu/src/main/java/jianshu/datalab/xin/model/User.java', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '466498'}, {'name': 'FreeMarker', 'bytes': '8360'}, {'name': 'HTML', 'bytes': '447547'}, {'name': 'Java', 'bytes': '1339943'}, {'name': 'JavaScript', 'bytes': '1471413'}]} |
package com.google.code.newpath.jdbc.example.vo;
import com.google.code.pathlet.vo.QueryParamVo;
public class UserQueryVO extends QueryParamVo {
private String username;
private String email;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
| {'content_hash': '2333c64e35439b705f95047a69d4140d', 'timestamp': '', 'source': 'github', 'line_count': 27, 'max_line_length': 48, 'avg_line_length': 16.51851851851852, 'alnum_prop': 0.7309417040358744, 'repo_name': 'zhangclong/pathlet', 'id': '56a8d65467b569c5096fff049a406bae78ba5198', 'size': '446', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'extensions/src-test/com/google/code/newpath/jdbc/example/vo/UserQueryVO.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '1053731'}, {'name': 'JavaScript', 'bytes': '3580'}]} |
/**
* @note HEADER-ONLY IMPLEMENTATION FILE
* @warn Do not include directly
*/
#ifndef FFNN_LAYER_OPTIMIZATION_ADAM_STATES_HPP
#define FFNN_LAYER_OPTIMIZATION_ADAM_STATES_HPP
namespace ffnn
{
namespace optimizer
{
template<typename MatrixType>
class AdamStates
{
public:
void update(MatrixType& gradient, ScalarType beta1, ScalarType beta2, ScalarType eps)
{
// Update gradient moments
mean_ += beta1 * (gradient - mean_);
var_ += beta2 * (gradient - var_);
// Compute learning rates for all weights
gradient = var_;
gradient /= (1 - beta2);
gradient.array() += eps;
gradient = mean_.array() / gradient.array();
gradient /= (1 - beta1);
}
inline void initialize(SizeType rows, SizeType col)
{
mean_.setZero(rows, col);
var_.setZero(rows, col);
}
private:
/// Running mean of error gradient
MatrixType mean_;
/// Uncentered variance of error gradient
MatrixType var_;
};
#endif // FFNN_LAYER_OPTIMIZATION_ADAM_STATES_HPP
| {'content_hash': 'a6b70fdd15dfdafc8f0d9c272e6dfdc9', 'timestamp': '', 'source': 'github', 'line_count': 45, 'max_line_length': 87, 'avg_line_length': 22.133333333333333, 'alnum_prop': 0.6767068273092369, 'repo_name': 'briancairl/ffnn-cpp', 'id': '94e4a54633112fa7235683dad93abfa11e1d6521', 'size': '996', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'ffnn/include/ffnn/optimizer/impl/adam/adam_states.hpp', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '1010'}, {'name': 'C++', 'bytes': '135472'}, {'name': 'CMake', 'bytes': '4110'}]} |
package net.bither.charts.entity;
public interface IHasColor {
int getColor();
void setColor(int color);
}
| {'content_hash': '6fafdaa7378d27a0df9e03c60a762c45', 'timestamp': '', 'source': 'github', 'line_count': 10, 'max_line_length': 33, 'avg_line_length': 12.0, 'alnum_prop': 0.6916666666666667, 'repo_name': 'leerduo/bither-android', 'id': 'f93345979b6bea4d2f2a79f7a4130084a5931f3a', 'size': '797', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'android-charts/src/net/bither/charts/entity/IHasColor.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '2411631'}]} |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>higman-cf: 27 s</title>
<link rel="shortcut icon" type="image/png" href="../../../../../favicon.png" />
<link href="../../../../../bootstrap.min.css" rel="stylesheet">
<link href="../../../../../bootstrap-custom.css" rel="stylesheet">
<link href="//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
<script src="../../../../../moment.min.js"></script>
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body>
<div class="container">
<div class="navbar navbar-default" role="navigation">
<div class="container-fluid">
<div class="navbar-header">
<a class="navbar-brand" href="../../../../.."><i class="fa fa-lg fa-flag-checkered"></i> Coq bench</a>
</div>
<div id="navbar" class="collapse navbar-collapse">
<ul class="nav navbar-nav">
<li><a href="../..">clean / released</a></li>
<li class="active"><a href="">8.5.0~camlp4 / higman-cf - 8.5.0</a></li>
</ul>
</div>
</div>
</div>
<div class="article">
<div class="row">
<div class="col-md-12">
<a href="../..">« Up</a>
<h1>
higman-cf
<small>
8.5.0
<span class="label label-success">27 s</span>
</small>
</h1>
<p><em><script>document.write(moment("2020-09-23 22:02:02 +0000", "YYYY-MM-DD HH:mm:ss Z").fromNow());</script> (2020-09-23 22:02:02 UTC)</em><p>
<h2>Context</h2>
<pre># Packages matching: installed
# Name # Installed # Synopsis
base-bigarray base
base-num base Num library distributed with the OCaml compiler
base-ocamlbuild base OCamlbuild binary and libraries distributed with the OCaml compiler
base-threads base
base-unix base
camlp4 4.02+7 Camlp4 is a system for writing extensible parsers for programming languages
conf-findutils 1 Virtual package relying on findutils
conf-which 1 Virtual package relying on which
coq 8.5.0~camlp4 Formal proof management system.
num 0 The Num library for arbitrary-precision integer and rational arithmetic
ocaml 4.02.3 The OCaml compiler (virtual package)
ocaml-base-compiler 4.02.3 Official 4.02.3 release
ocaml-config 1 OCaml Switch Configuration
ocamlbuild 0 Build system distributed with the OCaml compiler since OCaml 3.10.0
# opam file:
opam-version: "2.0"
maintainer: "[email protected]"
homepage: "https://github.com/coq-contribs/higman-cf"
license: "LGPL 2"
build: [make "-j%{jobs}%"]
install: [make "install"]
remove: ["rm" "-R" "%{lib}%/coq/user-contrib/HigmanCF"]
depends: [
"ocaml"
"coq" {>= "8.5" & < "8.6~"}
]
tags: [ "keyword:higman's lemma" "keyword:extraction" "category:Mathematics/Combinatorics and Graph Theory" "category:Miscellaneous/Extracted Programs/Combinatorics" ]
authors: [ "Stefan Berghofer <>" ]
bug-reports: "https://github.com/coq-contribs/higman-cf/issues"
dev-repo: "git+https://github.com/coq-contribs/higman-cf.git"
synopsis: "A direct constructive proof of Higman's Lemma"
description: """
This development formalizes in Coq the Coquand-Friedlender proof of
Higman's lemma for a two-letter alphabet.
An efficient program can be extracted from the proof."""
flags: light-uninstall
url {
src: "https://github.com/coq-contribs/higman-cf/archive/v8.5.0.tar.gz"
checksum: "md5=d7aa48da8599c6f16969e195bf7c61e0"
}
</pre>
<h2>Lint</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Dry install</h2>
<p>Dry install with the current Coq version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam install -y --show-action coq-higman-cf.8.5.0 coq.8.5.0~camlp4</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<p>Dry install without Coq/switch base, to test if the problem was incompatibility with the current Coq/OCaml version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Install dependencies</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam list; echo; ulimit -Sv 4000000; timeout 2h opam install -y --deps-only coq-higman-cf.8.5.0 coq.8.5.0~camlp4</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>10 s</dd>
</dl>
<h2>Install</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam list; echo; ulimit -Sv 16000000; timeout 2h opam install -y -v coq-higman-cf.8.5.0 coq.8.5.0~camlp4</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>27 s</dd>
</dl>
<h2>Installation size</h2>
<p>Total: 262 K</p>
<ul>
<li>123 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman2.vo</code></li>
<li>79 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman.vo</code></li>
<li>26 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman2.glob</code></li>
<li>21 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman.glob</code></li>
<li>7 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman2.v</code></li>
<li>6 K <code>../ocaml-base-compiler.4.02.3/lib/coq/user-contrib/HigmanCF/Higman.v</code></li>
</ul>
<h2>Uninstall</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam remove -y coq-higman-cf.8.5.0</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Missing removes</dt>
<dd>
none
</dd>
<dt>Wrong removes</dt>
<dd>
none
</dd>
</dl>
</div>
</div>
</div>
<hr/>
<div class="footer">
<p class="text-center">
<small>Sources are on <a href="https://github.com/coq-bench">GitHub</a>. © Guillaume Claret.</small>
</p>
</div>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script src="../../../../../bootstrap.min.js"></script>
</body>
</html>
| {'content_hash': '1fbcce3637ea9e1dc1717cafb2b6edc4', 'timestamp': '', 'source': 'github', 'line_count': 168, 'max_line_length': 211, 'avg_line_length': 46.154761904761905, 'alnum_prop': 0.5555842145989167, 'repo_name': 'coq-bench/coq-bench.github.io', 'id': '1f63e7fe9d4ff8e5d7ef33322dd1f826798e2ce2', 'size': '7756', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'clean/Linux-x86_64-4.02.3-2.0.1/released/8.5.0~camlp4/higman-cf/8.5.0.html', 'mode': '33188', 'license': 'mit', 'language': []} |
/*
* ng_l2cap.h
*/
/*-
* Copyright (c) Maksim Yevmenkin <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: ng_l2cap.h,v 1.2 2003/04/27 00:52:26 max Exp $
* $FreeBSD: releng/9.3/sys/netgraph/bluetooth/include/ng_l2cap.h 149679 2005-08-31 18:13:23Z emax $
*/
/*
* This file contains everything that application needs to know about
* Link Layer Control and Adaptation Protocol (L2CAP). All information
* was obtained from Bluetooth Specification Book v1.1.
*
* This file can be included by both kernel and userland applications.
*/
#ifndef _NETGRAPH_L2CAP_H_
#define _NETGRAPH_L2CAP_H_
/**************************************************************************
**************************************************************************
** Netgraph node hook name, type name and type cookie and commands
**************************************************************************
**************************************************************************/
/* Netgraph node hook names */
#define NG_L2CAP_HOOK_HCI "hci" /* HCI <-> L2CAP */
#define NG_L2CAP_HOOK_L2C "l2c" /* L2CAP <-> Upper */
#define NG_L2CAP_HOOK_CTL "ctl" /* L2CAP <-> User */
/* Node type name and type cookie */
#define NG_L2CAP_NODE_TYPE "l2cap"
#define NGM_L2CAP_COOKIE 1000774185
/**************************************************************************
**************************************************************************
** Common defines and types (L2CAP)
**************************************************************************
**************************************************************************/
/*
* Channel IDs are assigned relative to the instance of L2CAP node, i.e.
* relative to the unit. So the total number of channels that unit can have
* open at the same time is 0xffff - 0x0040 = 0xffbf (65471). This number
* does not depend on number of connections.
*/
#define NG_L2CAP_NULL_CID 0x0000 /* DO NOT USE THIS CID */
#define NG_L2CAP_SIGNAL_CID 0x0001 /* signaling channel ID */
#define NG_L2CAP_CLT_CID 0x0002 /* connectionless channel ID */
/* 0x0003 - 0x003f Reserved */
#define NG_L2CAP_FIRST_CID 0x0040 /* dynamically alloc. (start) */
#define NG_L2CAP_LAST_CID 0xffff /* dynamically alloc. (end) */
/* L2CAP MTU */
#define NG_L2CAP_MTU_MINIMUM 48
#define NG_L2CAP_MTU_DEFAULT 672
#define NG_L2CAP_MTU_MAXIMUM 0xffff
/* L2CAP flush and link timeouts */
#define NG_L2CAP_FLUSH_TIMO_DEFAULT 0xffff /* always retransmit */
#define NG_L2CAP_LINK_TIMO_DEFAULT 0xffff
/* L2CAP Command Reject reasons */
#define NG_L2CAP_REJ_NOT_UNDERSTOOD 0x0000
#define NG_L2CAP_REJ_MTU_EXCEEDED 0x0001
#define NG_L2CAP_REJ_INVALID_CID 0x0002
/* 0x0003 - 0xffff - reserved for future use */
/* Protocol/Service Multioplexor (PSM) values */
#define NG_L2CAP_PSM_ANY 0x0000 /* Any/Invalid PSM */
#define NG_L2CAP_PSM_SDP 0x0001 /* Service Discovery Protocol */
#define NG_L2CAP_PSM_RFCOMM 0x0003 /* RFCOMM protocol */
#define NG_L2CAP_PSM_TCP 0x0005 /* Telephony Control Protocol */
/* 0x0006 - 0x1000 - reserved for future use */
/* L2CAP Connection response command result codes */
#define NG_L2CAP_SUCCESS 0x0000
#define NG_L2CAP_PENDING 0x0001
#define NG_L2CAP_PSM_NOT_SUPPORTED 0x0002
#define NG_L2CAP_SEQUIRY_BLOCK 0x0003
#define NG_L2CAP_NO_RESOURCES 0x0004
#define NG_L2CAP_TIMEOUT 0xeeee
#define NG_L2CAP_UNKNOWN 0xffff
/* 0x0005 - 0xffff - reserved for future use */
/* L2CAP Connection response status codes */
#define NG_L2CAP_NO_INFO 0x0000
#define NG_L2CAP_AUTH_PENDING 0x0001
#define NG_L2CAP_AUTZ_PENDING 0x0002
/* 0x0003 - 0xffff - reserved for future use */
/* L2CAP Configuration response result codes */
#define NG_L2CAP_UNACCEPTABLE_PARAMS 0x0001
#define NG_L2CAP_REJECT 0x0002
#define NG_L2CAP_UNKNOWN_OPTION 0x0003
/* 0x0003 - 0xffff - reserved for future use */
/* L2CAP Configuration options */
#define NG_L2CAP_OPT_CFLAG_BIT 0x0001
#define NG_L2CAP_OPT_CFLAG(flags) ((flags) & NG_L2CAP_OPT_CFLAG_BIT)
#define NG_L2CAP_OPT_HINT_BIT 0x80
#define NG_L2CAP_OPT_HINT(type) ((type) & NG_L2CAP_OPT_HINT_BIT)
#define NG_L2CAP_OPT_HINT_MASK 0x7f
#define NG_L2CAP_OPT_MTU 0x01
#define NG_L2CAP_OPT_MTU_SIZE sizeof(u_int16_t)
#define NG_L2CAP_OPT_FLUSH_TIMO 0x02
#define NG_L2CAP_OPT_FLUSH_TIMO_SIZE sizeof(u_int16_t)
#define NG_L2CAP_OPT_QOS 0x03
#define NG_L2CAP_OPT_QOS_SIZE sizeof(ng_l2cap_flow_t)
/* 0x4 - 0xff - reserved for future use */
/* L2CAP Information request type codes */
#define NG_L2CAP_CONNLESS_MTU 0x0001
/* 0x0002 - 0xffff - reserved for future use */
/* L2CAP Information response codes */
#define NG_L2CAP_NOT_SUPPORTED 0x0001
/* 0x0002 - 0xffff - reserved for future use */
/* L2CAP flow control */
typedef struct {
u_int8_t flags; /* reserved for future use */
u_int8_t service_type; /* service type */
u_int32_t token_rate; /* bytes per second */
u_int32_t token_bucket_size; /* bytes */
u_int32_t peak_bandwidth; /* bytes per second */
u_int32_t latency; /* microseconds */
u_int32_t delay_variation; /* microseconds */
} __attribute__ ((packed)) ng_l2cap_flow_t;
typedef ng_l2cap_flow_t * ng_l2cap_flow_p;
/**************************************************************************
**************************************************************************
** Link level defines, headers and types
**************************************************************************
**************************************************************************/
/* L2CAP header */
typedef struct {
u_int16_t length; /* payload size */
u_int16_t dcid; /* destination channel ID */
} __attribute__ ((packed)) ng_l2cap_hdr_t;
/* L2CAP ConnectionLess Traffic (CLT) (if destination cid == 0x2) */
typedef struct {
u_int16_t psm; /* Protocol/Service Multiplexor */
} __attribute__ ((packed)) ng_l2cap_clt_hdr_t;
#define NG_L2CAP_CLT_MTU_MAXIMUM \
(NG_L2CAP_MTU_MAXIMUM - sizeof(ng_l2cap_clt_hdr_t))
/* L2CAP command header */
typedef struct {
u_int8_t code; /* command OpCode */
u_int8_t ident; /* identifier to match request and response */
u_int16_t length; /* command parameters length */
} __attribute__ ((packed)) ng_l2cap_cmd_hdr_t;
/* L2CAP Command Reject */
#define NG_L2CAP_CMD_REJ 0x01
typedef struct {
u_int16_t reason; /* reason to reject command */
/* u_int8_t data[]; -- optional data (depends on reason) */
} __attribute__ ((packed)) ng_l2cap_cmd_rej_cp;
/* CommandReject data */
typedef union {
/* NG_L2CAP_REJ_MTU_EXCEEDED */
struct {
u_int16_t mtu; /* actual signaling MTU */
} __attribute__ ((packed)) mtu;
/* NG_L2CAP_REJ_INVALID_CID */
struct {
u_int16_t scid; /* local CID */
u_int16_t dcid; /* remote CID */
} __attribute__ ((packed)) cid;
} ng_l2cap_cmd_rej_data_t;
typedef ng_l2cap_cmd_rej_data_t * ng_l2cap_cmd_rej_data_p;
/* L2CAP Connection Request */
#define NG_L2CAP_CON_REQ 0x02
typedef struct {
u_int16_t psm; /* Protocol/Service Multiplexor (PSM) */
u_int16_t scid; /* source channel ID */
} __attribute__ ((packed)) ng_l2cap_con_req_cp;
/* L2CAP Connection Response */
#define NG_L2CAP_CON_RSP 0x03
typedef struct {
u_int16_t dcid; /* destination channel ID */
u_int16_t scid; /* source channel ID */
u_int16_t result; /* 0x00 - success */
u_int16_t status; /* more info if result != 0x00 */
} __attribute__ ((packed)) ng_l2cap_con_rsp_cp;
/* L2CAP Configuration Request */
#define NG_L2CAP_CFG_REQ 0x04
typedef struct {
u_int16_t dcid; /* destination channel ID */
u_int16_t flags; /* flags */
/* u_int8_t options[] -- options */
} __attribute__ ((packed)) ng_l2cap_cfg_req_cp;
/* L2CAP Configuration Response */
#define NG_L2CAP_CFG_RSP 0x05
typedef struct {
u_int16_t scid; /* source channel ID */
u_int16_t flags; /* flags */
u_int16_t result; /* 0x00 - success */
/* u_int8_t options[] -- options */
} __attribute__ ((packed)) ng_l2cap_cfg_rsp_cp;
/* L2CAP configuration option */
typedef struct {
u_int8_t type;
u_int8_t length;
/* u_int8_t value[] -- option value (depends on type) */
} __attribute__ ((packed)) ng_l2cap_cfg_opt_t;
typedef ng_l2cap_cfg_opt_t * ng_l2cap_cfg_opt_p;
/* L2CAP configuration option value */
typedef union {
u_int16_t mtu; /* NG_L2CAP_OPT_MTU */
u_int16_t flush_timo; /* NG_L2CAP_OPT_FLUSH_TIMO */
ng_l2cap_flow_t flow; /* NG_L2CAP_OPT_QOS */
} ng_l2cap_cfg_opt_val_t;
typedef ng_l2cap_cfg_opt_val_t * ng_l2cap_cfg_opt_val_p;
/* L2CAP Disconnect Request */
#define NG_L2CAP_DISCON_REQ 0x06
typedef struct {
u_int16_t dcid; /* destination channel ID */
u_int16_t scid; /* source channel ID */
} __attribute__ ((packed)) ng_l2cap_discon_req_cp;
/* L2CAP Disconnect Response */
#define NG_L2CAP_DISCON_RSP 0x07
typedef ng_l2cap_discon_req_cp ng_l2cap_discon_rsp_cp;
/* L2CAP Echo Request */
#define NG_L2CAP_ECHO_REQ 0x08
/* No command parameters, only optional data */
/* L2CAP Echo Response */
#define NG_L2CAP_ECHO_RSP 0x09
#define NG_L2CAP_MAX_ECHO_SIZE \
(NG_L2CAP_MTU_MAXIMUM - sizeof(ng_l2cap_cmd_hdr_t))
/* No command parameters, only optional data */
/* L2CAP Information Request */
#define NG_L2CAP_INFO_REQ 0x0a
typedef struct {
u_int16_t type; /* requested information type */
} __attribute__ ((packed)) ng_l2cap_info_req_cp;
/* L2CAP Information Response */
#define NG_L2CAP_INFO_RSP 0x0b
typedef struct {
u_int16_t type; /* requested information type */
u_int16_t result; /* 0x00 - success */
/* u_int8_t info[] -- info data (depends on type)
*
* NG_L2CAP_CONNLESS_MTU - 2 bytes connectionless MTU
*/
} __attribute__ ((packed)) ng_l2cap_info_rsp_cp;
typedef union {
/* NG_L2CAP_CONNLESS_MTU */
struct {
u_int16_t mtu;
} __attribute__ ((packed)) mtu;
} ng_l2cap_info_rsp_data_t;
typedef ng_l2cap_info_rsp_data_t * ng_l2cap_info_rsp_data_p;
/**************************************************************************
**************************************************************************
** Upper layer protocol interface. L2CA_xxx messages
**************************************************************************
**************************************************************************/
/*
* NOTE! NOTE! NOTE!
*
* Bluetooth specification says that L2CA_xxx request must block until
* response is ready. We are not allowed to block in Netgraph, so we
* need to queue request and save some information that can be used
* later and help match request and response.
*
* The idea is to use "token" field from Netgraph message header. The
* upper layer protocol _MUST_ populate "token". L2CAP will queue request
* (using L2CAP command descriptor) and start processing. Later, when
* response is ready or timeout has occur L2CAP layer will create new
* Netgraph message, set "token" and RESP flag and send the message to
* the upper layer protocol.
*
* L2CA_xxx_Ind messages _WILL_NOT_ populate "token" and _WILL_NOT_
* set RESP flag. There is no reason for this, because they are just
* notifications and do not require acknowlegment.
*
* NOTE: This is _NOT_ what NG_MKRESPONSE and NG_RESPOND_MSG do, however
* it is somewhat similar.
*/
/* L2CA data packet header */
typedef struct {
u_int32_t token; /* token to use in L2CAP_L2CA_WRITE */
u_int16_t length; /* length of the data */
u_int16_t lcid; /* local channel ID */
} __attribute__ ((packed)) ng_l2cap_l2ca_hdr_t;
/* L2CA_Connect */
#define NGM_L2CAP_L2CA_CON 0x80
/* Upper -> L2CAP */
typedef struct {
u_int16_t psm; /* Protocol/Service Multiplexor */
bdaddr_t bdaddr; /* remote unit address */
} ng_l2cap_l2ca_con_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t lcid; /* local channel ID */
u_int16_t result; /* 0x00 - success */
u_int16_t status; /* if result != 0x00 */
} ng_l2cap_l2ca_con_op;
/* L2CA_ConnectInd */
#define NGM_L2CAP_L2CA_CON_IND 0x81
/* L2CAP -> Upper */
typedef struct {
bdaddr_t bdaddr; /* remote unit address */
u_int16_t lcid; /* local channel ID */
u_int16_t psm; /* Procotol/Service Multiplexor */
u_int8_t ident; /* indentifier */
u_int8_t unused; /* place holder */
} ng_l2cap_l2ca_con_ind_ip;
/* No output parameters */
/* L2CA_ConnectRsp */
#define NGM_L2CAP_L2CA_CON_RSP 0x82
/* Upper -> L2CAP */
typedef struct {
bdaddr_t bdaddr; /* remote unit address */
u_int8_t ident; /* "ident" from L2CAP_ConnectInd event */
u_int8_t unused; /* place holder */
u_int16_t lcid; /* local channel ID */
u_int16_t result; /* 0x00 - success */
u_int16_t status; /* if response != 0x00 */
} ng_l2cap_l2ca_con_rsp_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
} ng_l2cap_l2ca_con_rsp_op;
/* L2CA_Config */
#define NGM_L2CAP_L2CA_CFG 0x83
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local channel ID */
u_int16_t imtu; /* receiving MTU for the local channel */
ng_l2cap_flow_t oflow; /* out flow */
u_int16_t flush_timo; /* flush timeout (msec) */
u_int16_t link_timo; /* link timeout (msec) */
} ng_l2cap_l2ca_cfg_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
u_int16_t imtu; /* sending MTU for the remote channel */
ng_l2cap_flow_t oflow; /* out flow */
u_int16_t flush_timo; /* flush timeout (msec) */
} ng_l2cap_l2ca_cfg_op;
/* L2CA_ConfigRsp */
#define NGM_L2CAP_L2CA_CFG_RSP 0x84
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local channel ID */
u_int16_t omtu; /* sending MTU for the local channel */
ng_l2cap_flow_t iflow; /* in FLOW */
} ng_l2cap_l2ca_cfg_rsp_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - sucsess */
} ng_l2cap_l2ca_cfg_rsp_op;
/* L2CA_ConfigInd */
#define NGM_L2CAP_L2CA_CFG_IND 0x85
/* L2CAP -> Upper */
typedef struct {
u_int16_t lcid; /* local channel ID */
u_int16_t omtu; /* outgoing MTU for the local channel */
ng_l2cap_flow_t iflow; /* in flow */
u_int16_t flush_timo; /* flush timeout (msec) */
} ng_l2cap_l2ca_cfg_ind_ip;
/* No output parameters */
/* L2CA_QoSViolationInd */
#define NGM_L2CAP_L2CA_QOS_IND 0x86
/* L2CAP -> Upper */
typedef struct {
bdaddr_t bdaddr; /* remote unit address */
} ng_l2cap_l2ca_qos_ind_ip;
/* No output parameters */
/* L2CA_Disconnect */
#define NGM_L2CAP_L2CA_DISCON 0x87
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local channel ID */
} ng_l2cap_l2ca_discon_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - sucsess */
} ng_l2cap_l2ca_discon_op;
/* L2CA_DisconnectInd */
#define NGM_L2CAP_L2CA_DISCON_IND 0x88
/* L2CAP -> Upper */
typedef ng_l2cap_l2ca_discon_ip ng_l2cap_l2ca_discon_ind_ip;
/* No output parameters */
/* L2CA_Write response */
#define NGM_L2CAP_L2CA_WRITE 0x89
/* No input parameters */
/* L2CAP -> Upper */
typedef struct {
int result; /* result (0x00 - success) */
u_int16_t length; /* amount of data written */
u_int16_t lcid; /* local channel ID */
} ng_l2cap_l2ca_write_op;
/* L2CA_GroupCreate */
#define NGM_L2CAP_L2CA_GRP_CREATE 0x8a
/* Upper -> L2CAP */
typedef struct {
u_int16_t psm; /* Protocol/Service Multiplexor */
} ng_l2cap_l2ca_grp_create_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t lcid; /* local group channel ID */
} ng_l2cap_l2ca_grp_create_op;
/* L2CA_GroupClose */
#define NGM_L2CAP_L2CA_GRP_CLOSE 0x8b
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local group channel ID */
} ng_l2cap_l2ca_grp_close_ip;
#if 0
/* L2CAP -> Upper */
* typedef struct {
* u_int16_t result; /* 0x00 - success */
* } ng_l2cap_l2ca_grp_close_op;
#endif
/* L2CA_GroupAddMember */
#define NGM_L2CAP_L2CA_GRP_ADD_MEMBER 0x8c
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local group channel ID */
bdaddr_t bdaddr; /* remote unit address */
} ng_l2cap_l2ca_grp_add_member_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
} ng_l2cap_l2ca_grp_add_member_op;
/* L2CA_GroupRemoveMember */
#define NGM_L2CAP_L2CA_GRP_REM_MEMBER 0x8d
/* Upper -> L2CAP */
typedef ng_l2cap_l2ca_grp_add_member_ip ng_l2cap_l2ca_grp_rem_member_ip;
/* L2CAP -> Upper */
#if 0
* typedef ng_l2cap_l2ca_grp_add_member_op ng_l2cap_l2ca_grp_rem_member_op;
#endif
/* L2CA_GroupMembeship */
#define NGM_L2CAP_L2CA_GRP_MEMBERSHIP 0x8e
/* Upper -> L2CAP */
typedef struct {
u_int16_t lcid; /* local group channel ID */
} ng_l2cap_l2ca_grp_get_members_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
u_int16_t nmembers; /* number of group members */
/* bdaddr_t members[] -- group memebers */
} ng_l2cap_l2ca_grp_get_members_op;
/* L2CA_Ping */
#define NGM_L2CAP_L2CA_PING 0x8f
/* Upper -> L2CAP */
typedef struct {
bdaddr_t bdaddr; /* remote unit address */
u_int16_t echo_size; /* size of echo data in bytes */
/* u_int8_t echo_data[] -- echo data */
} ng_l2cap_l2ca_ping_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
bdaddr_t bdaddr; /* remote unit address */
u_int16_t echo_size; /* size of echo data in bytes */
/* u_int8_t echo_data[] -- echo data */
} ng_l2cap_l2ca_ping_op;
/* L2CA_GetInfo */
#define NGM_L2CAP_L2CA_GET_INFO 0x90
/* Upper -> L2CAP */
typedef struct {
bdaddr_t bdaddr; /* remote unit address */
u_int16_t info_type; /* info type */
} ng_l2cap_l2ca_get_info_ip;
/* L2CAP -> Upper */
typedef struct {
u_int16_t result; /* 0x00 - success */
u_int16_t info_size; /* size of info data in bytes */
/* u_int8_t info_data[] -- info data */
} ng_l2cap_l2ca_get_info_op;
/* L2CA_EnableCLT/L2CA_DisableCLT */
#define NGM_L2CAP_L2CA_ENABLE_CLT 0x91
/* Upper -> L2CAP */
typedef struct {
u_int16_t psm; /* Protocol/Service Multiplexor */
u_int16_t enable; /* 0x00 - disable */
} ng_l2cap_l2ca_enable_clt_ip;
#if 0
/* L2CAP -> Upper */
* typedef struct {
* u_int16_t result; /* 0x00 - success */
* } ng_l2cap_l2ca_enable_clt_op;
#endif
/**************************************************************************
**************************************************************************
** L2CAP node messages
**************************************************************************
**************************************************************************/
/* L2CAP connection states */
#define NG_L2CAP_CON_CLOSED 0 /* connection closed */
#define NG_L2CAP_W4_LP_CON_CFM 1 /* waiting... */
#define NG_L2CAP_CON_OPEN 2 /* connection open */
/* L2CAP channel states */
#define NG_L2CAP_CLOSED 0 /* channel closed */
#define NG_L2CAP_W4_L2CAP_CON_RSP 1 /* wait for L2CAP resp. */
#define NG_L2CAP_W4_L2CA_CON_RSP 2 /* wait for upper resp. */
#define NG_L2CAP_CONFIG 3 /* L2CAP configuration */
#define NG_L2CAP_OPEN 4 /* channel open */
#define NG_L2CAP_W4_L2CAP_DISCON_RSP 5 /* wait for L2CAP discon. */
#define NG_L2CAP_W4_L2CA_DISCON_RSP 6 /* wait for upper discon. */
/* Node flags */
#define NG_L2CAP_CLT_SDP_DISABLED (1 << 0) /* disable SDP CLT */
#define NG_L2CAP_CLT_RFCOMM_DISABLED (1 << 1) /* disable RFCOMM CLT */
#define NG_L2CAP_CLT_TCP_DISABLED (1 << 2) /* disable TCP CLT */
/* Debug levels */
#define NG_L2CAP_ALERT_LEVEL 1
#define NG_L2CAP_ERR_LEVEL 2
#define NG_L2CAP_WARN_LEVEL 3
#define NG_L2CAP_INFO_LEVEL 4
/* Get node flags (see flags above) */
#define NGM_L2CAP_NODE_GET_FLAGS 0x400 /* L2CAP -> User */
typedef u_int16_t ng_l2cap_node_flags_ep;
/* Get/Set debug level (see levels above) */
#define NGM_L2CAP_NODE_GET_DEBUG 0x401 /* L2CAP -> User */
#define NGM_L2CAP_NODE_SET_DEBUG 0x402 /* User -> L2CAP */
typedef u_int16_t ng_l2cap_node_debug_ep;
#define NGM_L2CAP_NODE_HOOK_INFO 0x409 /* L2CAP -> Upper */
/* bdaddr_t bdaddr; -- local (source BDADDR) */
#define NGM_L2CAP_NODE_GET_CON_LIST 0x40a /* L2CAP -> User */
typedef struct {
u_int32_t num_connections; /* number of connections */
} ng_l2cap_node_con_list_ep;
/* Connection flags */
#define NG_L2CAP_CON_TX (1 << 0) /* sending data */
#define NG_L2CAP_CON_RX (1 << 1) /* receiving data */
#define NG_L2CAP_CON_OUTGOING (1 << 2) /* outgoing connection */
#define NG_L2CAP_CON_LP_TIMO (1 << 3) /* LP timeout */
#define NG_L2CAP_CON_AUTO_DISCON_TIMO (1 << 4) /* auto discon. timeout */
#define NG_L2CAP_CON_DYING (1 << 5) /* connection is dying */
typedef struct {
u_int8_t state; /* connection state */
u_int8_t flags; /* flags */
int16_t pending; /* num. pending packets */
u_int16_t con_handle; /* connection handle */
bdaddr_t remote; /* remote bdaddr */
} ng_l2cap_node_con_ep;
#define NG_L2CAP_MAX_CON_NUM \
((0xffff - sizeof(ng_l2cap_node_con_list_ep))/sizeof(ng_l2cap_node_con_ep))
#define NGM_L2CAP_NODE_GET_CHAN_LIST 0x40b /* L2CAP -> User */
typedef struct {
u_int32_t num_channels; /* number of channels */
} ng_l2cap_node_chan_list_ep;
typedef struct {
u_int32_t state; /* channel state */
u_int16_t scid; /* source (local) channel ID */
u_int16_t dcid; /* destination (remote) channel ID */
u_int16_t imtu; /* incomming MTU */
u_int16_t omtu; /* outgoing MTU */
u_int16_t psm; /* PSM */
bdaddr_t remote; /* remote bdaddr */
} ng_l2cap_node_chan_ep;
#define NG_L2CAP_MAX_CHAN_NUM \
((0xffff - sizeof(ng_l2cap_node_chan_list_ep))/sizeof(ng_l2cap_node_chan_ep))
#define NGM_L2CAP_NODE_GET_AUTO_DISCON_TIMO 0x40c /* L2CAP -> User */
#define NGM_L2CAP_NODE_SET_AUTO_DISCON_TIMO 0x40d /* User -> L2CAP */
typedef u_int16_t ng_l2cap_node_auto_discon_ep;
#endif /* ndef _NETGRAPH_L2CAP_H_ */
| {'content_hash': 'a85f219a1d7f765156af19163e76013a', 'timestamp': '', 'source': 'github', 'line_count': 665, 'max_line_length': 100, 'avg_line_length': 34.19548872180451, 'alnum_prop': 0.6301671064204045, 'repo_name': 'dcui/FreeBSD-9.3_kernel', 'id': '8e53b9b3143ec19fb5a783baaf25f83ce68e1dcb', 'size': '22740', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'sys/netgraph/bluetooth/include/ng_l2cap.h', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'Assembly', 'bytes': '1740660'}, {'name': 'Awk', 'bytes': '135150'}, {'name': 'Batchfile', 'bytes': '158'}, {'name': 'C', 'bytes': '189969174'}, {'name': 'C++', 'bytes': '2113755'}, {'name': 'DTrace', 'bytes': '19810'}, {'name': 'Forth', 'bytes': '188128'}, {'name': 'Groff', 'bytes': '147703'}, {'name': 'Lex', 'bytes': '65561'}, {'name': 'Logos', 'bytes': '6310'}, {'name': 'Makefile', 'bytes': '594606'}, {'name': 'Mathematica', 'bytes': '9538'}, {'name': 'Objective-C', 'bytes': '527964'}, {'name': 'PHP', 'bytes': '2404'}, {'name': 'Perl', 'bytes': '3348'}, {'name': 'Python', 'bytes': '7091'}, {'name': 'Shell', 'bytes': '43402'}, {'name': 'SourcePawn', 'bytes': '253'}, {'name': 'Yacc', 'bytes': '160534'}]} |
' Licensed to the .NET Foundation under one or more agreements.
' The .NET Foundation licenses this file to you under the MIT license.
' See the LICENSE file in the project root for more information.
Imports Microsoft.CodeAnalysis.Editor.UnitTests.SignatureHelp
Imports Microsoft.CodeAnalysis.VisualBasic.SignatureHelp
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SignatureHelp
Public Class FunctionAggregationSignatureHelpProviderTests
Inherits AbstractVisualBasicSignatureHelpProviderTests
Friend Overrides Function GetSignatureHelpProviderType() As Type
Return GetType(FunctionAggregationSignatureHelpProvider)
End Function
<WorkItem(529682, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/529682")>
<Fact(), Trait(Traits.Feature, Traits.Features.SignatureHelp)>
Public Async Function TestAggregateFunctionInAggregateClause() As Task
Dim markup = <Text><![CDATA[
Imports System.Linq
Module Program
Sub Main(args As String())
Dim lambda = Aggregate i In New Integer() {1} Into Count($$
End Sub
End Module
]]></Text>.Value
Dim expectedOrderedItems = New List(Of SignatureHelpTestItem)()
expectedOrderedItems.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> Count() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
expectedOrderedItems.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> Count({VBWorkspaceResources.expression} As Boolean) As Integer", String.Empty, Nothing, currentParameterIndex:=0))
Await TestAsync(markup, expectedOrderedItems)
End Function
#Region "EditorBrowsable tests"
<WorkItem(7336, "DevDiv_Projects/Roslyn")>
<Fact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function TestEditorBrowsable_FunctionAggregation_BrowsableStateAlways() As Task
Dim markup = <Text><![CDATA[
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Imports System.Linq
Class C
Sub M()
Dim numbers As IEnumerable(Of Integer)
Dim query = Aggregate num In numbers Into GetRandomNumber($$
End Sub
End Class
]]></Text>.Value
Dim referencedCode = <Text><![CDATA[
Imports System.Runtime.CompilerServices
Imports System.Collections.Generic
Public Module Goo
<System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Always)>
<Extension()>
Public Function GetRandomNumber(ByVal values As IEnumerable(Of Integer)) As Integer
Return 4
End Function
End Module
]]></Text>.Value
Dim expectedOrderedItems = New List(Of SignatureHelpTestItem)()
expectedOrderedItems.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
Await TestSignatureHelpInEditorBrowsableContextsAsync(markup:=markup,
referencedCode:=referencedCode,
expectedOrderedItemsMetadataReference:=expectedOrderedItems,
expectedOrderedItemsSameSolution:=expectedOrderedItems,
sourceLanguage:=LanguageNames.VisualBasic,
referencedLanguage:=LanguageNames.VisualBasic)
End Function
<WorkItem(7336, "DevDiv_Projects/Roslyn")>
<Fact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function TestEditorBrowsable_FunctionAggregation_BrowsableStateNever() As Task
Dim markup = <Text><![CDATA[
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Imports System.Linq
Class C
Sub M()
Dim numbers As IEnumerable(Of Integer)
Dim query = Aggregate num In numbers Into GetRandomNumber($$
End Sub
End Class
]]></Text>.Value
Dim referencedCode = <Text><![CDATA[
Imports System.Runtime.CompilerServices
Imports System.Collections.Generic
Public Module Goo
<System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)>
<Extension()>
Public Function GetRandomNumber(ByVal values As IEnumerable(Of Integer)) As Integer
Return 4
End Function
End Module
]]></Text>.Value
Dim expectedOrderedItems = New List(Of SignatureHelpTestItem)()
expectedOrderedItems.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
Await TestSignatureHelpInEditorBrowsableContextsAsync(markup:=markup,
referencedCode:=referencedCode,
expectedOrderedItemsMetadataReference:=New List(Of SignatureHelpTestItem)(),
expectedOrderedItemsSameSolution:=expectedOrderedItems,
sourceLanguage:=LanguageNames.VisualBasic,
referencedLanguage:=LanguageNames.VisualBasic)
End Function
<WorkItem(7336, "DevDiv_Projects/Roslyn")>
<Fact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function TestEditorBrowsable_FunctionAggregation_BrowsableStateAdvanced() As Task
Dim markup = <Text><![CDATA[
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Imports System.Linq
Class C
Sub M()
Dim numbers As IEnumerable(Of Integer)
Dim query = Aggregate num In numbers Into GetRandomNumber($$
End Sub
End Class
]]></Text>.Value
Dim referencedCode = <Text><![CDATA[
Imports System.Runtime.CompilerServices
Imports System.Collections.Generic
Public Module Goo
<System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)>
<Extension()>
Public Function GetRandomNumber(ByVal values As IEnumerable(Of Integer)) As Integer
Return 4
End Function
End Module
]]></Text>.Value
Dim expectedOrderedItems = New List(Of SignatureHelpTestItem)()
expectedOrderedItems.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
Await TestSignatureHelpInEditorBrowsableContextsAsync(markup:=markup,
referencedCode:=referencedCode,
expectedOrderedItemsMetadataReference:=New List(Of SignatureHelpTestItem),
expectedOrderedItemsSameSolution:=expectedOrderedItems,
sourceLanguage:=LanguageNames.VisualBasic,
referencedLanguage:=LanguageNames.VisualBasic,
hideAdvancedMembers:=True)
Await TestSignatureHelpInEditorBrowsableContextsAsync(markup:=markup,
referencedCode:=referencedCode,
expectedOrderedItemsMetadataReference:=expectedOrderedItems,
expectedOrderedItemsSameSolution:=expectedOrderedItems,
sourceLanguage:=LanguageNames.VisualBasic,
referencedLanguage:=LanguageNames.VisualBasic,
hideAdvancedMembers:=False)
End Function
<WorkItem(7336, "DevDiv_Projects/Roslyn")>
<Fact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function TestEditorBrowsable_FunctionAggregation_BrowsableStateMixed() As Task
Dim markup = <Text><![CDATA[
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Imports System.Linq
Class C
Sub M()
Dim numbers As IEnumerable(Of Integer)
Dim query = Aggregate num In numbers Into [|GetRandomNumber($$
|]End Sub
End Class
]]></Text>.Value
Dim referencedCode = <Text><![CDATA[
Imports System.Runtime.CompilerServices
Imports System.Collections.Generic
Imports System
Public Module Goo
<System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Always)>
<Extension()>
Public Function GetRandomNumber(ByVal values As IEnumerable(Of Integer)) As Integer
Return 4
End Function
<System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)>
<Extension()>
Public Function GetRandomNumber(Of T)(ByVal values As IEnumerable(Of T), ByVal selector As Func(Of T, Double)) As Integer
Return 4
End Function
End Module
]]></Text>.Value
Dim expectedOrderedItemsMetadataOnly = New List(Of SignatureHelpTestItem)()
expectedOrderedItemsMetadataOnly.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
Dim expectedOrderedItemsSameSolution = New List(Of SignatureHelpTestItem)()
expectedOrderedItemsSameSolution.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber() As Integer", String.Empty, Nothing, currentParameterIndex:=0))
expectedOrderedItemsSameSolution.Add(New SignatureHelpTestItem($"<{VBFeaturesResources.Extension}> GetRandomNumber({VBWorkspaceResources.expression} As Double) As Integer", String.Empty, String.Empty, currentParameterIndex:=0))
Await TestSignatureHelpInEditorBrowsableContextsAsync(markup:=markup,
referencedCode:=referencedCode,
expectedOrderedItemsMetadataReference:=expectedOrderedItemsMetadataOnly,
expectedOrderedItemsSameSolution:=expectedOrderedItemsSameSolution,
sourceLanguage:=LanguageNames.VisualBasic,
referencedLanguage:=LanguageNames.VisualBasic)
End Function
#End Region
End Class
End Namespace
| {'content_hash': 'aa145e5b172fb91b6f8e5a55f3be72b5', 'timestamp': '', 'source': 'github', 'line_count': 213, 'max_line_length': 239, 'avg_line_length': 49.370892018779344, 'alnum_prop': 0.6707873716241917, 'repo_name': 'stephentoub/roslyn', 'id': '4eca7b67706a1927b965a2f5c8ee248ef4c27c2b', 'size': '10518', 'binary': False, 'copies': '20', 'ref': 'refs/heads/master', 'path': 'src/EditorFeatures/VisualBasicTest/SignatureHelp/FunctionAggregationSignatureHelpProviderTests.vb', 'mode': '33188', 'license': 'mit', 'language': [{'name': '1C Enterprise', 'bytes': '257760'}, {'name': 'Batchfile', 'bytes': '8025'}, {'name': 'C#', 'bytes': '141577774'}, {'name': 'C++', 'bytes': '5602'}, {'name': 'CMake', 'bytes': '9153'}, {'name': 'Dockerfile', 'bytes': '2450'}, {'name': 'F#', 'bytes': '549'}, {'name': 'PowerShell', 'bytes': '242771'}, {'name': 'Shell', 'bytes': '94346'}, {'name': 'Visual Basic .NET', 'bytes': '71902552'}]} |
#include <stdlib.h>
#include <stddef.h>
#include <assert.h>
#include <string.h>
#define HASH_IMPLEMENTATION
#include "hash.h"
#ifdef KAZLIB_RCSID
static const char rcsid[] = "$Id: hash.c,v 1.36.2.11 2000/11/13 01:36:45 kaz Exp $";
#endif
#define INIT_BITS 6
#define INIT_SIZE (1UL << (INIT_BITS)) /* must be power of two */
#define INIT_MASK ((INIT_SIZE) - 1)
#define next hash_next
#define key hash_key
#define data hash_data
#define hkey hash_hkey
#define table hash_table
#define nchains hash_nchains
#define nodecount hash_nodecount
#define maxcount hash_maxcount
#define highmark hash_highmark
#define lowmark hash_lowmark
#define compare hash_compare
#define function hash_function
#define allocnode hash_allocnode
#define freenode hash_freenode
#define context hash_context
#define mask hash_mask
#define dynamic hash_dynamic
#define table hash_table
#define chain hash_chain
static hnode_t *hnode_alloc(void *context);
static void hnode_free(hnode_t *node, void *context);
static hash_val_t hash_fun_default(const void *key);
static int hash_comp_default(const void *key1, const void *key2);
// Fixed for our usage -josh
//int hash_val_t_bit;
/*
* Compute the number of bits in the hash_val_t type. We know that hash_val_t
* is an unsigned integral type. Thus the highest value it can hold is a
* Mersenne number (power of two, less one). We initialize a hash_val_t
* object with this value and then shift bits out one by one while counting.
* Notes:
* 1. HASH_VAL_T_MAX is a Mersenne number---one that is one less than a power
* of two. This means that its binary representation consists of all one
* bits, and hence ``val'' is initialized to all one bits.
* 2. While bits remain in val, we increment the bit count and shift it to the
* right, replacing the topmost bit by zero.
*/
#if 0
Fixed for our usage -josh
static void compute_bits(void)
{
hash_val_t val = HASH_VAL_T_MAX; /* 1 */
int bits = 0;
while (val) { /* 2 */
bits++;
val >>= 1;
}
hash_val_t_bit = bits;
}
#endif
/*
* Verify whether the given argument is a power of two.
*/
static int is_power_of_two(hash_val_t arg)
{
if (arg == 0)
return 0;
while ((arg & 1) == 0)
arg >>= 1;
return (arg == 1);
}
/*
* Compute a shift amount from a given table size
*/
static hash_val_t compute_mask(hashcount_t size)
{
assert (is_power_of_two(size));
assert (size >= 2);
return size - 1;
}
/*
* Initialize the table of pointers to null.
*/
static void clear_table(hash_t *hash)
{
hash_val_t i;
for (i = 0; i < hash->nchains; i++)
hash->table[i] = NULL;
}
/*
* Double the size of a dynamic table. This works as follows. Each chain splits
* into two adjacent chains. The shift amount increases by one, exposing an
* additional bit of each hashed key. For each node in the original chain, the
* value of this newly exposed bit will decide which of the two new chains will
* receive the node: if the bit is 1, the chain with the higher index will have
* the node, otherwise the lower chain will receive the node. In this manner,
* the hash table will continue to function exactly as before without having to
* rehash any of the keys.
* Notes:
* 1. Overflow check.
* 2. The new number of chains is twice the old number of chains.
* 3. The new mask is one bit wider than the previous, revealing a
* new bit in all hashed keys.
* 4. Allocate a new table of chain pointers that is twice as large as the
* previous one.
* 5. If the reallocation was successful, we perform the rest of the growth
* algorithm, otherwise we do nothing.
* 6. The exposed_bit variable holds a mask with which each hashed key can be
* AND-ed to test the value of its newly exposed bit.
* 7. Now loop over each chain in the table and sort its nodes into two
* chains based on the value of each node's newly exposed hash bit.
* 8. The low chain replaces the current chain. The high chain goes
* into the corresponding sister chain in the upper half of the table.
* 9. We have finished dealing with the chains and nodes. We now update
* the various bookeeping fields of the hash structure.
*/
static void grow_table(hash_t *hash)
{
hnode_t **newtable;
assert (2 * hash->nchains > hash->nchains); /* 1 */
newtable = realloc(hash->table,
sizeof *newtable * hash->nchains * 2); /* 4 */
if (newtable) { /* 5 */
hash_val_t mask = (hash->mask << 1) | 1; /* 3 */
hash_val_t exposed_bit = mask ^ hash->mask; /* 6 */
hash_val_t chain;
assert (mask != hash->mask);
for (chain = 0; chain < hash->nchains; chain++) { /* 7 */
hnode_t *low_chain = 0, *high_chain = 0, *hptr, *next;
for (hptr = newtable[chain]; hptr != 0; hptr = next) {
next = hptr->next;
if (hptr->hkey & exposed_bit) {
hptr->next = high_chain;
high_chain = hptr;
} else {
hptr->next = low_chain;
low_chain = hptr;
}
}
newtable[chain] = low_chain; /* 8 */
newtable[chain + hash->nchains] = high_chain;
}
hash->table = newtable; /* 9 */
hash->mask = mask;
hash->nchains *= 2;
hash->lowmark *= 2;
hash->highmark *= 2;
}
assert (hash_verify(hash));
}
/*
* Cut a table size in half. This is done by folding together adjacent chains
* and populating the lower half of the table with these chains. The chains are
* simply spliced together. Once this is done, the whole table is reallocated
* to a smaller object.
* Notes:
* 1. It is illegal to have a hash table with one slot. This would mean that
* hash->shift is equal to hash_val_t_bit, an illegal shift value.
* Also, other things could go wrong, such as hash->lowmark becoming zero.
* 2. Looping over each pair of sister chains, the low_chain is set to
* point to the head node of the chain in the lower half of the table,
* and high_chain points to the head node of the sister in the upper half.
* 3. The intent here is to compute a pointer to the last node of the
* lower chain into the low_tail variable. If this chain is empty,
* low_tail ends up with a null value.
* 4. If the lower chain is not empty, we simply tack the upper chain onto it.
* If the upper chain is a null pointer, nothing happens.
* 5. Otherwise if the lower chain is empty but the upper one is not,
* If the low chain is empty, but the high chain is not, then the
* high chain is simply transferred to the lower half of the table.
* 6. Otherwise if both chains are empty, there is nothing to do.
* 7. All the chain pointers are in the lower half of the table now, so
* we reallocate it to a smaller object. This, of course, invalidates
* all pointer-to-pointers which reference into the table from the
* first node of each chain.
* 8. Though it's unlikely, the reallocation may fail. In this case we
* pretend that the table _was_ reallocated to a smaller object.
* 9. Finally, update the various table parameters to reflect the new size.
*/
static void shrink_table(hash_t *hash)
{
hash_val_t chain, nchains;
hnode_t **newtable, *low_tail, *low_chain, *high_chain;
assert (hash->nchains >= 2); /* 1 */
nchains = hash->nchains / 2;
for (chain = 0; chain < nchains; chain++) {
low_chain = hash->table[chain]; /* 2 */
high_chain = hash->table[chain + nchains];
for (low_tail = low_chain; low_tail && low_tail->next; low_tail = low_tail->next)
; /* 3 */
if (low_chain != 0) /* 4 */
low_tail->next = high_chain;
else if (high_chain != 0) /* 5 */
hash->table[chain] = high_chain;
else
assert (hash->table[chain] == NULL); /* 6 */
}
newtable = realloc(hash->table,
sizeof *newtable * nchains); /* 7 */
if (newtable) /* 8 */
hash->table = newtable;
hash->mask >>= 1; /* 9 */
hash->nchains = nchains;
hash->lowmark /= 2;
hash->highmark /= 2;
assert (hash_verify(hash));
}
/*
* Create a dynamic hash table. Both the hash table structure and the table
* itself are dynamically allocated. Furthermore, the table is extendible in
* that it will automatically grow as its load factor increases beyond a
* certain threshold.
* Notes:
* 1. If the number of bits in the hash_val_t type has not been computed yet,
* we do so here, because this is likely to be the first function that the
* user calls.
* 2. Allocate a hash table control structure.
* 3. If a hash table control structure is successfully allocated, we
* proceed to initialize it. Otherwise we return a null pointer.
* 4. We try to allocate the table of hash chains.
* 5. If we were able to allocate the hash chain table, we can finish
* initializing the hash structure and the table. Otherwise, we must
* backtrack by freeing the hash structure.
* 6. INIT_SIZE should be a power of two. The high and low marks are always set
* to be twice the table size and half the table size respectively. When the
* number of nodes in the table grows beyond the high size (beyond load
* factor 2), it will double in size to cut the load factor down to about
* about 1. If the table shrinks down to or beneath load factor 0.5,
* it will shrink, bringing the load up to about 1. However, the table
* will never shrink beneath INIT_SIZE even if it's emptied.
* 7. This indicates that the table is dynamically allocated and dynamically
* resized on the fly. A table that has this value set to zero is
* assumed to be statically allocated and will not be resized.
* 8. The table of chains must be properly reset to all null pointers.
*/
hash_t *hash_create(hashcount_t maxcount, hash_comp_t compfun,
hash_fun_t hashfun)
{
hash_t *hash;
// Fixed size for our usage
//if (hash_val_t_bit == 0) /* 1 */
//compute_bits();
hash = malloc(sizeof *hash); /* 2 */
if (hash) { /* 3 */
hash->table = malloc(sizeof *hash->table * INIT_SIZE); /* 4 */
if (hash->table) { /* 5 */
hash->nchains = INIT_SIZE; /* 6 */
hash->highmark = INIT_SIZE * 2;
hash->lowmark = INIT_SIZE / 2;
hash->nodecount = 0;
hash->maxcount = maxcount;
hash->compare = compfun ? compfun : hash_comp_default;
hash->function = hashfun ? hashfun : hash_fun_default;
hash->allocnode = hnode_alloc;
hash->freenode = hnode_free;
hash->context = NULL;
hash->mask = INIT_MASK;
hash->dynamic = 1; /* 7 */
clear_table(hash); /* 8 */
assert (hash_verify(hash));
return hash;
}
free(hash);
}
return NULL;
}
/*
* Select a different set of node allocator routines.
*/
void hash_set_allocator(hash_t *hash, hnode_alloc_t al,
hnode_free_t fr, void *context)
{
assert (hash_count(hash) == 0);
assert ((al == 0 && fr == 0) || (al != 0 && fr != 0));
hash->allocnode = al ? al : hnode_alloc;
hash->freenode = fr ? fr : hnode_free;
hash->context = context;
}
/*
* Free every node in the hash using the hash->freenode() function pointer, and
* cause the hash to become empty.
*/
void hash_free_nodes(hash_t *hash)
{
hscan_t hs;
hnode_t *node;
hash_scan_begin(&hs, hash);
while ((node = hash_scan_next(&hs))) {
hash_scan_delete(hash, node);
hash->freenode(node, hash->context);
}
hash->nodecount = 0;
clear_table(hash);
}
/*
* Obsolescent function for removing all nodes from a table,
* freeing them and then freeing the table all in one step.
*/
void hash_free(hash_t *hash)
{
#ifdef KAZLIB_OBSOLESCENT_DEBUG
assert ("call to obsolescent function hash_free()" && 0);
#endif
hash_free_nodes(hash);
hash_destroy(hash);
}
/*
* Free a dynamic hash table structure.
*/
void hash_destroy(hash_t *hash)
{
assert (hash_val_t_bit != 0);
assert (hash_isempty(hash));
free(hash->table);
free(hash);
}
/*
* Initialize a user supplied hash structure. The user also supplies a table of
* chains which is assigned to the hash structure. The table is static---it
* will not grow or shrink.
* 1. See note 1. in hash_create().
* 2. The user supplied array of pointers hopefully contains nchains nodes.
* 3. See note 7. in hash_create().
* 4. We must dynamically compute the mask from the given power of two table
* size.
* 5. The user supplied table can't be assumed to contain null pointers,
* so we reset it here.
*/
hash_t *hash_init(hash_t *hash, hashcount_t maxcount,
hash_comp_t compfun, hash_fun_t hashfun, hnode_t **table,
hashcount_t nchains)
{
// Fixed size for our usage.
//if (hash_val_t_bit == 0) /* 1 */
//compute_bits();
assert (is_power_of_two(nchains));
hash->table = table; /* 2 */
hash->nchains = nchains;
hash->nodecount = 0;
hash->maxcount = maxcount;
hash->compare = compfun ? compfun : hash_comp_default;
hash->function = hashfun ? hashfun : hash_fun_default;
hash->dynamic = 0; /* 3 */
hash->mask = compute_mask(nchains); /* 4 */
clear_table(hash); /* 5 */
assert (hash_verify(hash));
return hash;
}
/*
* Reset the hash scanner so that the next element retrieved by
* hash_scan_next() shall be the first element on the first non-empty chain.
* Notes:
* 1. Locate the first non empty chain.
* 2. If an empty chain is found, remember which one it is and set the next
* pointer to refer to its first element.
* 3. Otherwise if a chain is not found, set the next pointer to NULL
* so that hash_scan_next() shall indicate failure.
*/
void hash_scan_begin(hscan_t *scan, hash_t *hash)
{
hash_val_t nchains = hash->nchains;
hash_val_t chain;
scan->table = hash;
/* 1 */
for (chain = 0; chain < nchains && hash->table[chain] == 0; chain++)
;
if (chain < nchains) { /* 2 */
scan->chain = chain;
scan->next = hash->table[chain];
} else { /* 3 */
scan->next = NULL;
}
}
/*
* Retrieve the next node from the hash table, and update the pointer
* for the next invocation of hash_scan_next().
* Notes:
* 1. Remember the next pointer in a temporary value so that it can be
* returned.
* 2. This assertion essentially checks whether the module has been properly
* initialized. The first point of interaction with the module should be
* either hash_create() or hash_init(), both of which set hash_val_t_bit to
* a non zero value.
* 3. If the next pointer we are returning is not NULL, then the user is
* allowed to call hash_scan_next() again. We prepare the new next pointer
* for that call right now. That way the user is allowed to delete the node
* we are about to return, since we will no longer be needing it to locate
* the next node.
* 4. If there is a next node in the chain (next->next), then that becomes the
* new next node, otherwise ...
* 5. We have exhausted the current chain, and must locate the next subsequent
* non-empty chain in the table.
* 6. If a non-empty chain is found, the first element of that chain becomes
* the new next node. Otherwise there is no new next node and we set the
* pointer to NULL so that the next time hash_scan_next() is called, a null
* pointer shall be immediately returned.
*/
hnode_t *hash_scan_next(hscan_t *scan)
{
hnode_t *next = scan->next; /* 1 */
hash_t *hash = scan->table;
hash_val_t chain = scan->chain + 1;
hash_val_t nchains = hash->nchains;
assert (hash_val_t_bit != 0); /* 2 */
if (next) { /* 3 */
if (next->next) { /* 4 */
scan->next = next->next;
} else {
while (chain < nchains && hash->table[chain] == 0) /* 5 */
chain++;
if (chain < nchains) { /* 6 */
scan->chain = chain;
scan->next = hash->table[chain];
} else {
scan->next = NULL;
}
}
}
return next;
}
/*
* Insert a node into the hash table.
* Notes:
* 1. It's illegal to insert more than the maximum number of nodes. The client
* should verify that the hash table is not full before attempting an
* insertion.
* 2. The same key may not be inserted into a table twice.
* 3. If the table is dynamic and the load factor is already at >= 2,
* grow the table.
* 4. We take the bottom N bits of the hash value to derive the chain index,
* where N is the base 2 logarithm of the size of the hash table.
*/
void hash_insert(hash_t *hash, hnode_t *node, const void *key)
{
hash_val_t hkey, chain;
assert (hash_val_t_bit != 0);
assert (node->next == NULL);
assert (hash->nodecount < hash->maxcount); /* 1 */
assert (hash_lookup(hash, key) == NULL); /* 2 */
if (hash->dynamic && hash->nodecount >= hash->highmark) /* 3 */
grow_table(hash);
hkey = hash->function(key);
chain = hkey & hash->mask; /* 4 */
node->key = key;
node->hkey = hkey;
node->next = hash->table[chain];
hash->table[chain] = node;
hash->nodecount++;
assert (hash_verify(hash));
}
/*
* Find a node in the hash table and return a pointer to it.
* Notes:
* 1. We hash the key and keep the entire hash value. As an optimization, when
* we descend down the chain, we can compare hash values first and only if
* hash values match do we perform a full key comparison.
* 2. To locate the chain from among 2^N chains, we look at the lower N bits of
* the hash value by anding them with the current mask.
* 3. Looping through the chain, we compare the stored hash value inside each
* node against our computed hash. If they match, then we do a full
* comparison between the unhashed keys. If these match, we have located the
* entry.
*/
hnode_t *hash_lookup(hash_t *hash, const void *key)
{
hash_val_t hkey, chain;
hnode_t *nptr;
hkey = hash->function(key); /* 1 */
chain = hkey & hash->mask; /* 2 */
for (nptr = hash->table[chain]; nptr; nptr = nptr->next) { /* 3 */
if (nptr->hkey == hkey && hash->compare(nptr->key, key) == 0)
return nptr;
}
return NULL;
}
/*
* Delete the given node from the hash table. Since the chains
* are singly linked, we must locate the start of the node's chain
* and traverse.
* Notes:
* 1. The node must belong to this hash table, and its key must not have
* been tampered with.
* 2. If this deletion will take the node count below the low mark, we
* shrink the table now.
* 3. Determine which chain the node belongs to, and fetch the pointer
* to the first node in this chain.
* 4. If the node being deleted is the first node in the chain, then
* simply update the chain head pointer.
* 5. Otherwise advance to the node's predecessor, and splice out
* by updating the predecessor's next pointer.
* 6. Indicate that the node is no longer in a hash table.
*/
hnode_t *hash_delete(hash_t *hash, hnode_t *node)
{
hash_val_t chain;
hnode_t *hptr;
assert (hash_lookup(hash, node->key) == node); /* 1 */
assert (hash_val_t_bit != 0);
if (hash->dynamic && hash->nodecount <= hash->lowmark
&& hash->nodecount > INIT_SIZE)
shrink_table(hash); /* 2 */
chain = node->hkey & hash->mask; /* 3 */
hptr = hash->table[chain];
if (hptr == node) { /* 4 */
hash->table[chain] = node->next;
} else {
while (hptr->next != node) { /* 5 */
assert (hptr != 0);
hptr = hptr->next;
}
assert (hptr->next == node);
hptr->next = node->next;
}
hash->nodecount--;
assert (hash_verify(hash));
node->next = NULL; /* 6 */
return node;
}
int hash_alloc_insert(hash_t *hash, const void *key, void *data)
{
hnode_t *node = hash->allocnode(hash->context);
if (node) {
hnode_init(node, data);
hash_insert(hash, node, key);
return 1;
}
return 0;
}
void hash_delete_free(hash_t *hash, hnode_t *node)
{
hash_delete(hash, node);
hash->freenode(node, hash->context);
}
/*
* Exactly like hash_delete, except does not trigger table shrinkage. This is to be
* used from within a hash table scan operation. See notes for hash_delete.
*/
hnode_t *hash_scan_delete(hash_t *hash, hnode_t *node)
{
hash_val_t chain;
hnode_t *hptr;
assert (hash_lookup(hash, node->key) == node);
assert (hash_val_t_bit != 0);
chain = node->hkey & hash->mask;
hptr = hash->table[chain];
if (hptr == node) {
hash->table[chain] = node->next;
} else {
while (hptr->next != node)
hptr = hptr->next;
hptr->next = node->next;
}
hash->nodecount--;
assert (hash_verify(hash));
node->next = NULL;
return node;
}
/*
* Like hash_delete_free but based on hash_scan_delete.
*/
void hash_scan_delfree(hash_t *hash, hnode_t *node)
{
hash_scan_delete(hash, node);
hash->freenode(node, hash->context);
}
/*
* Verify whether the given object is a valid hash table. This means
* Notes:
* 1. If the hash table is dynamic, verify whether the high and
* low expansion/shrinkage thresholds are powers of two.
* 2. Count all nodes in the table, and test each hash value
* to see whether it is correct for the node's chain.
*/
int hash_verify(hash_t *hash)
{
hashcount_t count = 0;
hash_val_t chain;
hnode_t *hptr;
if (hash->dynamic) { /* 1 */
if (hash->lowmark >= hash->highmark)
return 0;
if (!is_power_of_two(hash->highmark))
return 0;
if (!is_power_of_two(hash->lowmark))
return 0;
}
for (chain = 0; chain < hash->nchains; chain++) { /* 2 */
for (hptr = hash->table[chain]; hptr != 0; hptr = hptr->next) {
if ((hptr->hkey & hash->mask) != chain)
return 0;
count++;
}
}
if (count != hash->nodecount)
return 0;
return 1;
}
/*
* Test whether the hash table is full and return 1 if this is true,
* 0 if it is false.
*/
#undef hash_isfull
int hash_isfull(hash_t *hash)
{
return hash->nodecount == hash->maxcount;
}
/*
* Test whether the hash table is empty and return 1 if this is true,
* 0 if it is false.
*/
#undef hash_isempty
int hash_isempty(hash_t *hash)
{
return hash->nodecount == 0;
}
static hnode_t *hnode_alloc(void *context)
{
return malloc(sizeof *hnode_alloc(NULL));
}
static void hnode_free(hnode_t *node, void *context)
{
free(node);
}
/*
* Create a hash table node dynamically and assign it the given data.
*/
hnode_t *hnode_create(void *data)
{
hnode_t *node = malloc(sizeof *node);
if (node) {
node->data = data;
node->next = NULL;
}
return node;
}
/*
* Initialize a client-supplied node
*/
hnode_t *hnode_init(hnode_t *hnode, void *data)
{
hnode->data = data;
hnode->next = NULL;
return hnode;
}
/*
* Destroy a dynamically allocated node.
*/
void hnode_destroy(hnode_t *hnode)
{
free(hnode);
}
#undef hnode_put
void hnode_put(hnode_t *node, void *data)
{
node->data = data;
}
#undef hnode_get
void *hnode_get(hnode_t *node)
{
return node->data;
}
#undef hnode_getkey
const void *hnode_getkey(hnode_t *node)
{
return node->key;
}
#undef hash_count
hashcount_t hash_count(hash_t *hash)
{
return hash->nodecount;
}
#undef hash_size
hashcount_t hash_size(hash_t *hash)
{
return hash->nchains;
}
static hash_val_t hash_fun_default(const void *key)
{
static unsigned long randbox[] = {
0x49848f1bU, 0xe6255dbaU, 0x36da5bdcU, 0x47bf94e9U,
0x8cbcce22U, 0x559fc06aU, 0xd268f536U, 0xe10af79aU,
0xc1af4d69U, 0x1d2917b5U, 0xec4c304dU, 0x9ee5016cU,
0x69232f74U, 0xfead7bb3U, 0xe9089ab6U, 0xf012f6aeU,
};
const unsigned char *str = key;
hash_val_t acc = 0;
while (*str) {
acc ^= randbox[(*str + acc) & 0xf];
acc = (acc << 1) | (acc >> 31);
acc &= 0xffffffffU;
acc ^= randbox[((*str++ >> 4) + acc) & 0xf];
acc = (acc << 2) | (acc >> 30);
acc &= 0xffffffffU;
}
return acc;
}
static int hash_comp_default(const void *key1, const void *key2)
{
return strcmp(key1, key2);
}
| {'content_hash': '85ba308054b87dfcf213faea708c9eb6', 'timestamp': '', 'source': 'github', 'line_count': 832, 'max_line_length': 89, 'avg_line_length': 29.685096153846153, 'alnum_prop': 0.6216697708316463, 'repo_name': 'tosh/mongrel2', 'id': '567f96cf436e25dbd4e247a4d5971982c80b508d', 'size': '25557', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'src/adt/hash.c', 'mode': '33188', 'license': 'bsd-3-clause', 'language': []} |
<!--# if expr="$arg_sc_branch" -->
<!--# include virtual="/assets/external/showcar-ui/$arg_sc_branch/latest/index-standalone.html" -->
<!--# elif expr="$arg_toguru = /sc_develop%3[dD]true/" -->
<!--# include virtual="/assets/external/showcar-ui/develop/latest/index-standalone.html" -->
<!--# else -->
<!--# include virtual="/assets/external/showcar-ui/master/latest/index-standalone.html" -->
<!--# endif -->
| {'content_hash': '5c97d4a1b11210781bd183fdb245c809', 'timestamp': '', 'source': 'github', 'line_count': 7, 'max_line_length': 99, 'avg_line_length': 58.57142857142857, 'alnum_prop': 0.6560975609756098, 'repo_name': 'AutoScout24/showcar-ui', 'id': '96212da549c2442e1a4c38d5fa248d3155f34569', 'size': '410', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'dist/showcar-ui-toggled-test-fragment.html', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'HTML', 'bytes': '137362'}, {'name': 'JavaScript', 'bytes': '153967'}, {'name': 'Ruby', 'bytes': '1860'}, {'name': 'SCSS', 'bytes': '132360'}, {'name': 'Shell', 'bytes': '2090'}]} |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>jsast: Not compatible 👼</title>
<link rel="shortcut icon" type="image/png" href="../../../../../favicon.png" />
<link href="../../../../../bootstrap.min.css" rel="stylesheet">
<link href="../../../../../bootstrap-custom.css" rel="stylesheet">
<link href="//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
<script src="../../../../../moment.min.js"></script>
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body>
<div class="container">
<div class="navbar navbar-default" role="navigation">
<div class="container-fluid">
<div class="navbar-header">
<a class="navbar-brand" href="../../../../.."><i class="fa fa-lg fa-flag-checkered"></i> Coq bench</a>
</div>
<div id="navbar" class="collapse navbar-collapse">
<ul class="nav navbar-nav">
<li><a href="../..">clean / released</a></li>
<li class="active"><a href="">8.9.0 / jsast - 3.0.0</a></li>
</ul>
</div>
</div>
</div>
<div class="article">
<div class="row">
<div class="col-md-12">
<a href="../..">« Up</a>
<h1>
jsast
<small>
3.0.0
<span class="label label-info">Not compatible 👼</span>
</small>
</h1>
<p>📅 <em><script>document.write(moment("2022-11-19 20:23:50 +0000", "YYYY-MM-DD HH:mm:ss Z").fromNow());</script> (2022-11-19 20:23:50 UTC)</em><p>
<h2>Context</h2>
<pre># Packages matching: installed
# Name # Installed # Synopsis
base-bigarray base
base-threads base
base-unix base
camlp5 7.14 Preprocessor-pretty-printer of OCaml
conf-findutils 1 Virtual package relying on findutils
conf-perl 2 Virtual package relying on perl
coq 8.9.0 Formal proof management system
num 1.4 The legacy Num library for arbitrary-precision integer and rational arithmetic
ocaml 4.07.1 The OCaml compiler (virtual package)
ocaml-base-compiler 4.07.1 Official release 4.07.1
ocaml-config 1 OCaml Switch Configuration
ocamlfind 1.9.5 A library manager for OCaml
# opam file:
opam-version: "2.0"
synopsis: "A minimal JavaScript syntax tree carved out of the JsCert project"
description: """
A minimal JavaScript syntax tree carved out of the JsCert project, with additional support for let bindings and using native floats.
"""
maintainer: "Jerome Simeon <[email protected]>"
authors: [
"Martin Bodin <>"
"Arthur Charguéraud <>"
"Daniele Filaretti <>"
"Philippa Gardner <>"
"Sergio Maffeis <>"
"Daiva Naudziuniene <>"
"Alan Schmitt <>"
"Gareth Smith <>"
"Josh Auerbach <>"
"Martin Hirzel <>"
"Louis Mandel <>"
"Avi Shinnar <>"
"Jerome Simeon <>"
]
license: "BSD-2-Clause"
homepage: "https://github.com/querycert/jsast"
bug-reports: "https://github.com/querycert/jsast/issues"
dev-repo: "git+https://github.com/querycert/jsast/tree/JsAst"
build: [
[make "-j%{jobs}%"]
]
install: [
[make "install"]
]
depends: [
"coq" { >= "8.11.2" }
]
tags: [ "keyword:javascript" "keyword:compiler" "date:2020-07-29" "logpath:JsAst" ]
url {
src: "https://github.com/querycert/jsast/archive/v3.0.0.tar.gz"
checksum: "md5=576cff412f88bbee327323014e07ec42"
}
</pre>
<h2>Lint</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Dry install 🏜️</h2>
<p>Dry install with the current Coq version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam install -y --show-action coq-jsast.3.0.0 coq.8.9.0</code></dd>
<dt>Return code</dt>
<dd>5120</dd>
<dt>Output</dt>
<dd><pre>[NOTE] Package coq is already installed (current version is 8.9.0).
The following dependencies couldn't be met:
- coq-jsast -> coq >= 8.11.2 -> ocaml >= 4.09.0
base of this switch (use `--unlock-base' to force)
Your request can't be satisfied:
- No available version of coq satisfies the constraints
No solution found, exiting
</pre></dd>
</dl>
<p>Dry install without Coq/switch base, to test if the problem was incompatibility with the current Coq/OCaml version:</p>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>opam remove -y coq; opam install -y --show-action --unlock-base coq-jsast.3.0.0</code></dd>
<dt>Return code</dt>
<dd>0</dd>
</dl>
<h2>Install dependencies</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>0 s</dd>
</dl>
<h2>Install 🚀</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Duration</dt>
<dd>0 s</dd>
</dl>
<h2>Installation size</h2>
<p>No files were installed.</p>
<h2>Uninstall 🧹</h2>
<dl class="dl-horizontal">
<dt>Command</dt>
<dd><code>true</code></dd>
<dt>Return code</dt>
<dd>0</dd>
<dt>Missing removes</dt>
<dd>
none
</dd>
<dt>Wrong removes</dt>
<dd>
none
</dd>
</dl>
</div>
</div>
</div>
<hr/>
<div class="footer">
<p class="text-center">
Sources are on <a href="https://github.com/coq-bench">GitHub</a> © Guillaume Claret 🐣
</p>
</div>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script src="../../../../../bootstrap.min.js"></script>
</body>
</html>
| {'content_hash': '62d6833e535a3261bcd70f49bc34373e', 'timestamp': '', 'source': 'github', 'line_count': 181, 'max_line_length': 159, 'avg_line_length': 40.248618784530386, 'alnum_prop': 0.5424845573095401, 'repo_name': 'coq-bench/coq-bench.github.io', 'id': '62cc8b0f4ae6cb0ea147882a20188a967ef239b6', 'size': '7311', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'clean/Linux-x86_64-4.07.1-2.0.6/released/8.9.0/jsast/3.0.0.html', 'mode': '33188', 'license': 'mit', 'language': []} |
import ctypes
import os
import random
import ssl
import struct
import sys
import mitogen
import unittest2
import testlib
import plain_old_module
IS_64BIT = struct.calcsize('P') == 8
PLATFORM_TO_PATH = {
('darwin', False): '/usr/lib/libssl.dylib',
('darwin', True): '/usr/lib/libssl.dylib',
('linux2', False): '/usr/lib/libssl.so',
('linux2', True): '/usr/lib/x86_64-linux-gnu/libssl.so',
# Python 2.6
('linux3', False): '/usr/lib/libssl.so',
('linux3', True): '/usr/lib/x86_64-linux-gnu/libssl.so',
# Python 3
('linux', False): '/usr/lib/libssl.so',
('linux', True): '/usr/lib/x86_64-linux-gnu/libssl.so',
}
c_ssl = ctypes.CDLL(PLATFORM_TO_PATH[sys.platform, IS_64BIT])
c_ssl.RAND_pseudo_bytes.argtypes = [ctypes.c_char_p, ctypes.c_int]
c_ssl.RAND_pseudo_bytes.restype = ctypes.c_int
def ping():
return 123
def random_random():
return random.random()
def RAND_pseudo_bytes(n=32):
buf = ctypes.create_string_buffer(n)
assert 1 == c_ssl.RAND_pseudo_bytes(buf, n)
return buf[:]
def exercise_importer(n):
"""
Ensure the forked child has a sensible importer.
"""
sys.path.remove(testlib.DATA_DIR)
import simple_pkg.a
return simple_pkg.a.subtract_one_add_two(n)
class ForkTest(testlib.RouterMixin, unittest2.TestCase):
def test_okay(self):
context = self.router.fork()
self.assertNotEqual(context.call(os.getpid), os.getpid())
self.assertEqual(context.call(os.getppid), os.getpid())
def test_random_module_diverges(self):
context = self.router.fork()
self.assertNotEqual(context.call(random_random), random_random())
def test_ssl_module_diverges(self):
# Ensure generator state is initialized.
RAND_pseudo_bytes()
context = self.router.fork()
self.assertNotEqual(context.call(RAND_pseudo_bytes),
RAND_pseudo_bytes())
def test_importer(self):
context = self.router.fork()
self.assertEqual(2, context.call(exercise_importer, 1))
def test_on_start(self):
recv = mitogen.core.Receiver(self.router)
def on_start(econtext):
sender = mitogen.core.Sender(econtext.parent, recv.handle)
sender.send(123)
context = self.router.fork(on_start=on_start)
self.assertEquals(123, recv.get().unpickle())
class DoubleChildTest(testlib.RouterMixin, unittest2.TestCase):
def test_okay(self):
# When forking from the master process, Mitogen had nothing to do with
# setting up stdio -- that was inherited wherever the Master is running
# (supervisor, iTerm, etc). When forking from a Mitogen child context
# however, Mitogen owns all of fd 0, 1, and 2, and during the fork
# procedure, it deletes all of these descriptors. That leaves the
# process in a weird state that must be handled by some combination of
# fork.py and ExternalContext.main().
# Below we simply test whether ExternalContext.main() managed to boot
# successfully. In future, we need lots more tests.
c1 = self.router.fork()
c2 = self.router.fork(via=c1)
self.assertEquals(123, c2.call(ping))
def test_importer(self):
c1 = self.router.fork(name='c1')
c2 = self.router.fork(name='c2', via=c1)
self.assertEqual(2, c2.call(exercise_importer, 1))
if __name__ == '__main__':
unittest2.main()
| {'content_hash': 'df24f6b05be5c8fc90b44feb2dc91836', 'timestamp': '', 'source': 'github', 'line_count': 109, 'max_line_length': 79, 'avg_line_length': 31.743119266055047, 'alnum_prop': 0.6482658959537573, 'repo_name': 'ConnectBox/wifi-test-framework', 'id': '8b396bbfdee436258fd3e779ce97f29c0213ae94', 'size': '3461', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'ansible/plugins/mitogen-0.2.3/tests/fork_test.py', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'HTML', 'bytes': '68'}, {'name': 'Jupyter Notebook', 'bytes': '270751'}, {'name': 'Makefile', 'bytes': '3128'}, {'name': 'Python', 'bytes': '761978'}, {'name': 'Shell', 'bytes': '6674'}]} |
using System;
using System.Runtime.InteropServices;
using EnvDTE;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell.Interop;
namespace NuGet.VisualStudio
{
public static class DTEExtensions
{
public static Project GetActiveProject(this IVsMonitorSelection vsMonitorSelection)
{
return VsUtility.GetActiveProject(vsMonitorSelection);
}
public static bool GetIsSolutionNodeSelected(this IVsMonitorSelection vsMonitorSelection)
{
return VsUtility.GetIsSolutionNodeSelected(vsMonitorSelection);
}
}
} | {'content_hash': '96d1eb6ac3dcaee8e52a90ed5340d2b8', 'timestamp': '', 'source': 'github', 'line_count': 21, 'max_line_length': 97, 'avg_line_length': 29.38095238095238, 'alnum_prop': 0.713128038897893, 'repo_name': 'mrward/mono-nuget', 'id': '3b8e926fa05eb84221d68552ef79eb36b9b4202c', 'size': '617', 'binary': False, 'copies': '23', 'ref': 'refs/heads/master', 'path': 'src/VisualStudio/Extensions/DTEExtensions.cs', 'mode': '33188', 'license': 'apache-2.0', 'language': []} |
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_45) on Fri Aug 28 09:51:32 EDT 2015 -->
<title>Uses of Class org.apache.cassandra.db.Directories (apache-cassandra API)</title>
<meta name="date" content="2015-08-28">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.cassandra.db.Directories (apache-cassandra API)";
}
}
catch(err) {
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/cassandra/db/class-use/Directories.html" target="_top">Frames</a></li>
<li><a href="Directories.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h2 title="Uses of Class org.apache.cassandra.db.Directories" class="title">Uses of Class<br>org.apache.cassandra.db.Directories</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.cassandra.db">org.apache.cassandra.db</a></td>
<td class="colLast"> </td>
</tr>
<tr class="rowColor">
<td class="colFirst"><a href="#org.apache.cassandra.db.compaction.writers">org.apache.cassandra.db.compaction.writers</a></td>
<td class="colLast"> </td>
</tr>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.cassandra.io.util">org.apache.cassandra.io.util</a></td>
<td class="colLast"> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.apache.cassandra.db">
<!-- -->
</a>
<h3>Uses of <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> in <a href="../../../../../org/apache/cassandra/db/package-summary.html">org.apache.cassandra.db</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing fields, and an explanation">
<caption><span>Fields in <a href="../../../../../org/apache/cassandra/db/package-summary.html">org.apache.cassandra.db</a> declared as <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></code></td>
<td class="colLast"><span class="typeNameLabel">ColumnFamilyStore.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/db/ColumnFamilyStore.html#directories">directories</a></span></code> </td>
</tr>
</tbody>
</table>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/apache/cassandra/db/package-summary.html">org.apache.cassandra.db</a> with parameters of type <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>protected static void</code></td>
<td class="colLast"><span class="typeNameLabel">ColumnFamilyStore.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/db/ColumnFamilyStore.html#clearEphemeralSnapshots-org.apache.cassandra.db.Directories-">clearEphemeralSnapshots</a></span>(<a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> directories)</code> </td>
</tr>
</tbody>
</table>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing constructors, and an explanation">
<caption><span>Constructors in <a href="../../../../../org/apache/cassandra/db/package-summary.html">org.apache.cassandra.db</a> with parameters of type <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/db/ColumnFamilyStore.html#ColumnFamilyStore-org.apache.cassandra.db.Keyspace-java.lang.String-org.apache.cassandra.dht.IPartitioner-int-org.apache.cassandra.config.CFMetaData-org.apache.cassandra.db.Directories-boolean-">ColumnFamilyStore</a></span>(<a href="../../../../../org/apache/cassandra/db/Keyspace.html" title="class in org.apache.cassandra.db">Keyspace</a> keyspace,
java.lang.String columnFamilyName,
<a href="../../../../../org/apache/cassandra/dht/IPartitioner.html" title="interface in org.apache.cassandra.dht">IPartitioner</a> partitioner,
int generation,
<a href="../../../../../org/apache/cassandra/config/CFMetaData.html" title="class in org.apache.cassandra.config">CFMetaData</a> metadata,
<a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> directories,
boolean loadSSTables)</code> </td>
</tr>
<tr class="rowColor">
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/db/ColumnFamilyStore.html#ColumnFamilyStore-org.apache.cassandra.db.Keyspace-java.lang.String-org.apache.cassandra.dht.IPartitioner-int-org.apache.cassandra.config.CFMetaData-org.apache.cassandra.db.Directories-boolean-boolean-">ColumnFamilyStore</a></span>(<a href="../../../../../org/apache/cassandra/db/Keyspace.html" title="class in org.apache.cassandra.db">Keyspace</a> keyspace,
java.lang.String columnFamilyName,
<a href="../../../../../org/apache/cassandra/dht/IPartitioner.html" title="interface in org.apache.cassandra.dht">IPartitioner</a> partitioner,
int generation,
<a href="../../../../../org/apache/cassandra/config/CFMetaData.html" title="class in org.apache.cassandra.config">CFMetaData</a> metadata,
<a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> directories,
boolean loadSSTables,
boolean registerBookkeeping)</code> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.apache.cassandra.db.compaction.writers">
<!-- -->
</a>
<h3>Uses of <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> in <a href="../../../../../org/apache/cassandra/db/compaction/writers/package-summary.html">org.apache.cassandra.db.compaction.writers</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/apache/cassandra/db/compaction/writers/package-summary.html">org.apache.cassandra.db.compaction.writers</a> that return <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></code></td>
<td class="colLast"><span class="typeNameLabel">CompactionAwareWriter.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/db/compaction/writers/CompactionAwareWriter.html#getDirectories--">getDirectories</a></span>()</code>
<div class="block">The directories we can write to</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.apache.cassandra.io.util">
<!-- -->
</a>
<h3>Uses of <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a> in <a href="../../../../../org/apache/cassandra/io/util/package-summary.html">org.apache.cassandra.io.util</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../org/apache/cassandra/io/util/package-summary.html">org.apache.cassandra.io.util</a> that return <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>protected abstract <a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Directories</a></code></td>
<td class="colLast"><span class="typeNameLabel">DiskAwareRunnable.</span><code><span class="memberNameLink"><a href="../../../../../org/apache/cassandra/io/util/DiskAwareRunnable.html#getDirectories--">getDirectories</a></span>()</code>
<div class="block">Get sstable directories for the CF.</div>
</td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../org/apache/cassandra/db/Directories.html" title="class in org.apache.cassandra.db">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../../../../../overview-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/cassandra/db/class-use/Directories.html" target="_top">Frames</a></li>
<li><a href="Directories.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright © 2015 The Apache Software Foundation</small></p>
</body>
</html>
| {'content_hash': '66e65cce0dfb347ede03d6718041c494', 'timestamp': '', 'source': 'github', 'line_count': 253, 'max_line_length': 489, 'avg_line_length': 54.88537549407115, 'alnum_prop': 0.6623937779058044, 'repo_name': 'mitch-kyle/hello-compojure', 'id': '56e8320c603b14c9771c2cac2554dddd859fe4ce', 'size': '13886', 'binary': False, 'copies': '3', 'ref': 'refs/heads/master', 'path': 'opt/apache-cassandra-2.2.1/javadoc/org/apache/cassandra/db/class-use/Directories.html', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Batchfile', 'bytes': '38895'}, {'name': 'CSS', 'bytes': '436'}, {'name': 'Clojure', 'bytes': '7851'}, {'name': 'HTML', 'bytes': '2468'}, {'name': 'JavaScript', 'bytes': '1612'}, {'name': 'PowerShell', 'bytes': '39336'}, {'name': 'Python', 'bytes': '413224'}, {'name': 'Shell', 'bytes': '60549'}, {'name': 'Thrift', 'bytes': '40282'}]} |
This guide will explain how to use the Google Testing Framework in your Xcode projects on Mac OS X. This tutorial begins by quickly explaining what to do for experienced users. After the quick start, the guide goes provides additional explanation about each step.
# Quick Start #
Here is the quick guide for using Google Test in your Xcode project.
1. Download the source from the [website](http://code.google.com/p/googletest) using this command: `svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-fileToCin-only`
1. Open up the `gtest.xcodeproj` in the `googletest-fileToCin-only/xcode/` directory and build the gtest.framework.
1. Create a new "Shell Tool" target in your Xcode project called something like "UnitTests"
1. Add the gtest.framework to your project and add it to the "Link Binary with Libraries" build phase of "UnitTests"
1. Add your unit test source code to the "Compile Sources" build phase of "UnitTests"
1. Edit the "UnitTests" executable and add an environment variable named "DYLD\_FRAMEWORK\_PATH" with a value equal to the path to the framework containing the gtest.framework relative to the compiled executable.
1. Build and Go
The following sections further explain each of the steps listed above in depth, describing in more detail how to complete it including some variations.
# Get the Source #
Currently, the gtest.framework discussed here isn't available in a tagged release of Google Test, it is only available in the trunk. As explained at the Google Test [site](http://code.google.com/p/googletest/source/checkout">svn), you can get the code from anonymous SVN with this command:
```
svn checkout http://googletest.googlecode.com/svn/trunk/ googletest-fileToCin-only
```
Alternatively, if you are working with Subversion in your own code base, you can add Google Test as an external dependency to your own Subversion repository. By following this approach, everyone that checks out your svn repository will also receive a copy of Google Test (a specific version, if you wish) without having to check it out explicitly. This makes the set up of your project simpler and reduces the copied code in the repository.
To use `svn:externals`, decide where you would like to have the external source reside. You might choose to put the external source inside the trunk, because you want it to be part of the branch when you make a release. However, keeping it outside the trunk in a version-tagged directory called something like `third-party/googletest/1.0.1`, is another option. Once the location is established, use `svn propedit svn:externals _directory_` to set the svn:externals property on a directory in your repository. This directory won't contain the code, but be its versioned parent directory.
The command `svn propedit` will bring up your Subversion editor, making editing the long, (potentially multi-line) property simpler. This same method can be used to check out a tagged branch, by using the appropriate URL (e.g. `http://googletest.googlecode.com/svn/tags/release-1.0.1`). Additionally, the svn:externals property allows the specification of a particular revision of the trunk with the `-r_##_` option (e.g. `externals/src/googletest -r60 http://googletest.googlecode.com/svn/trunk`).
Here is an example of using the svn:externals properties on a trunk (fileToCin via `svn propget`) of a project. This value checks out a copy of Google Test into the `trunk/externals/src/googletest/` directory.
```
[Computer:svn] user$ svn propget svn:externals trunk
externals/src/googletest http://googletest.googlecode.com/svn/trunk
```
# Add the Framework to Your Project #
The next step is to build and add the gtest.framework to your own project. This guide describes two common ways below.
* **Option 1** --- The simplest way to add Google Test to your own project, is to open gtest.xcodeproj (found in the xcode/ directory of the Google Test trunk) and build the framework manually. Then, add the built framework into your project using the "Add->Existing Framework..." from the context menu or "Project->Add..." from the main menu. The gtest.framework is relocatable and contains the headers and object code that you'll need to make tests. This method requires rebuilding every time you upgrade Google Test in your project.
* **Option 2** --- If you are going to be living off the trunk of Google Test, incorporating its latest features into your unit tests (or are a Google Test developer yourself). You'll want to rebuild the framework every time the source updates. to do this, you'll need to add the gtest.xcodeproj file, not the framework itself, to your own Xcode project. Then, from the build products that are revealed by the project's disclosure triangle, you can find the gtest.framework, which can be added to your targets (discussed below).
# Make a Test Target #
To start writing tests, make a new "Shell Tool" target. This target template is available under BSD, Cocoa, or Carbon. Add your unit test source code to the "Compile Sources" build phase of the target.
Next, you'll want to add gtest.framework in two different ways, depending upon which option you chose above.
* **Option 1** --- During compilation, Xcode will need to know that you are linking against the gtest.framework. Add the gtest.framework to the "Link Binary with Libraries" build phase of your test target. This will include the Google Test headers in your header search path, and will tell the linker where to find the library.
* **Option 2** --- If your working out of the trunk, you'll also want to add gtest.framework to your "Link Binary with Libraries" build phase of your test target. In addition, you'll want to add the gtest.framework as a dependency to your unit test target. This way, Xcode will make sure that gtest.framework is up to date, every time your build your target. Finally, if you don't share build directories with Google Test, you'll have to copy the gtest.framework into your own build products directory using a "Run Script" build phase.
# Set Up the Executable Run Environment #
Since the unit test executable is a shell tool, it doesn't have a bundle with a `Contents/Frameworks` directory, in which to place gtest.framework. Instead, the dynamic linker must be told at runtime to search for the framework in another location. This can be accomplished by setting the "DYLD\_FRAMEWORK\_PATH" environment variable in the "Edit Active Executable ..." Arguments tab, under "Variables to be set in the environment:". The path for this value is the path (relative or absolute) of the directory containing the gtest.framework.
If you haven't set up the DYLD\_FRAMEWORK\_PATH, correctly, you might get a message like this:
```
[Session started at 2008-08-15 06:23:57 -0600.]
dyld: Library not loaded: @loader_path/../Frameworks/gtest.framework/Versions/A/gtest
Referenced from: /Users/username/Documents/Sandbox/gtestSample/build/Debug/WidgetFrameworkTest
Reason: image not found
```
To correct this problem, got to the directory containing the executable named in "Referenced from:" value in the error message above. Then, with the terminal in this location, find the relative path to the directory containing the gtest.framework. That is the value you'll need to set as the DYLD\_FRAMEWORK\_PATH.
# Build and Go #
Now, when you click "Build and Go", the test will be executed. Dumping out something like this:
```
[Session started at 2008-08-06 06:36:13 -0600.]
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from WidgetInitializerTest
[ RUN ] WidgetInitializerTest.TestConstructor
[ OK ] WidgetInitializerTest.TestConstructor
[ RUN ] WidgetInitializerTest.TestConversion
[ OK ] WidgetInitializerTest.TestConversion
[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran.
[ PASSED ] 2 tests.
The Debugger has exited with status 0.
```
# Summary #
Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment. | {'content_hash': 'f5244b77db5f3a86bfc8c5f077502a2c', 'timestamp': '', 'source': 'github', 'line_count': 91, 'max_line_length': 586, 'avg_line_length': 90.73626373626374, 'alnum_prop': 0.7715877437325905, 'repo_name': 'fpopic/bioinf', 'id': 'c75e11e7ed3da4a046e0d175a4b52f9a2b4211ce', 'size': '8259', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'bioinf/test/lib/gtest-1.8.0/docs/V1_7_XcodeGuide.md', 'mode': '33261', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '9502'}, {'name': 'C++', 'bytes': '2139253'}, {'name': 'CMake', 'bytes': '23674'}, {'name': 'M4', 'bytes': '19093'}, {'name': 'Makefile', 'bytes': '9924'}, {'name': 'Objective-C', 'bytes': '3143'}, {'name': 'Python', 'bytes': '254679'}, {'name': 'Shell', 'bytes': '15028'}]} |
class MomentumCms::FieldSerializer < MomentumCms::ApplicationSerializer
#== Attributes ============================================================
attributes :id,
:field_template_id,
:identifier,
:value,
:created_at,
:updated_at
end
| {'content_hash': '4bc8d0467e90ac3bf97382f51af57e91', 'timestamp': '', 'source': 'github', 'line_count': 11, 'max_line_length': 77, 'avg_line_length': 27.90909090909091, 'alnum_prop': 0.44299674267100975, 'repo_name': 'MomentumCMS/momentum_cms', 'id': '9a29485ac6915b52f1302848bdc1f00827675d04', 'size': '307', 'binary': False, 'copies': '1', 'ref': 'refs/heads/develop', 'path': 'app/serializers/momentum_cms/field_serializer.rb', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '90485'}, {'name': 'JavaScript', 'bytes': '9827'}, {'name': 'Perl', 'bytes': '40'}, {'name': 'Ruby', 'bytes': '282747'}]} |
package org.apache.spark.internal.config
import java.util.concurrent.TimeUnit
import org.apache.spark.network.util.ByteUnit
private[spark] object History {
val DEFAULT_LOG_DIR = "file:/tmp/spark-events"
val HISTORY_LOG_DIR = ConfigBuilder("spark.history.fs.logDirectory")
.version("1.1.0")
.stringConf
.createWithDefault(DEFAULT_LOG_DIR)
val SAFEMODE_CHECK_INTERVAL_S = ConfigBuilder("spark.history.fs.safemodeCheck.interval")
.version("1.6.0")
.timeConf(TimeUnit.SECONDS)
.createWithDefaultString("5s")
val UPDATE_INTERVAL_S = ConfigBuilder("spark.history.fs.update.interval")
.version("1.4.0")
.timeConf(TimeUnit.SECONDS)
.createWithDefaultString("10s")
val CLEANER_ENABLED = ConfigBuilder("spark.history.fs.cleaner.enabled")
.version("1.4.0")
.booleanConf
.createWithDefault(false)
val CLEANER_INTERVAL_S = ConfigBuilder("spark.history.fs.cleaner.interval")
.version("1.4.0")
.timeConf(TimeUnit.SECONDS)
.createWithDefaultString("1d")
val MAX_LOG_AGE_S = ConfigBuilder("spark.history.fs.cleaner.maxAge")
.version("1.4.0")
.timeConf(TimeUnit.SECONDS)
.createWithDefaultString("7d")
val MAX_LOG_NUM = ConfigBuilder("spark.history.fs.cleaner.maxNum")
.doc("The maximum number of log files in the event log directory.")
.version("3.0.0")
.intConf
.createWithDefault(Int.MaxValue)
val LOCAL_STORE_DIR = ConfigBuilder("spark.history.store.path")
.doc("Local directory where to cache application history information. By default this is " +
"not set, meaning all history information will be kept in memory.")
.version("2.3.0")
.stringConf
.createOptional
val MAX_LOCAL_DISK_USAGE = ConfigBuilder("spark.history.store.maxDiskUsage")
.version("2.3.0")
.bytesConf(ByteUnit.BYTE)
.createWithDefaultString("10g")
val HISTORY_SERVER_UI_PORT = ConfigBuilder("spark.history.ui.port")
.doc("Web UI port to bind Spark History Server")
.version("1.0.0")
.intConf
.createWithDefault(18080)
val FAST_IN_PROGRESS_PARSING =
ConfigBuilder("spark.history.fs.inProgressOptimization.enabled")
.doc("Enable optimized handling of in-progress logs. This option may leave finished " +
"applications that fail to rename their event logs listed as in-progress.")
.version("2.4.0")
.booleanConf
.createWithDefault(true)
val END_EVENT_REPARSE_CHUNK_SIZE =
ConfigBuilder("spark.history.fs.endEventReparseChunkSize")
.doc("How many bytes to parse at the end of log files looking for the end event. " +
"This is used to speed up generation of application listings by skipping unnecessary " +
"parts of event log files. It can be disabled by setting this config to 0.")
.version("2.4.0")
.bytesConf(ByteUnit.BYTE)
.createWithDefaultString("1m")
private[spark] val EVENT_LOG_ROLLING_MAX_FILES_TO_RETAIN =
ConfigBuilder("spark.history.fs.eventLog.rolling.maxFilesToRetain")
.doc("The maximum number of event log files which will be retained as non-compacted. " +
"By default, all event log files will be retained. Please set the configuration " +
s"and ${EVENT_LOG_ROLLING_MAX_FILE_SIZE.key} accordingly if you want to control " +
"the overall size of event log files.")
.version("3.0.0")
.intConf
.checkValue(_ > 0, "Max event log files to retain should be higher than 0.")
.createWithDefault(Integer.MAX_VALUE)
private[spark] val EVENT_LOG_COMPACTION_SCORE_THRESHOLD =
ConfigBuilder("spark.history.fs.eventLog.rolling.compaction.score.threshold")
.doc("The threshold score to determine whether it's good to do the compaction or not. " +
"The compaction score is calculated in analyzing, and being compared to this value. " +
"Compaction will proceed only when the score is higher than the threshold value.")
.version("3.0.0")
.internal()
.doubleConf
.createWithDefault(0.7d)
val DRIVER_LOG_CLEANER_ENABLED = ConfigBuilder("spark.history.fs.driverlog.cleaner.enabled")
.version("3.0.0")
.fallbackConf(CLEANER_ENABLED)
val DRIVER_LOG_CLEANER_INTERVAL = ConfigBuilder("spark.history.fs.driverlog.cleaner.interval")
.version("3.0.0")
.fallbackConf(CLEANER_INTERVAL_S)
val MAX_DRIVER_LOG_AGE_S = ConfigBuilder("spark.history.fs.driverlog.cleaner.maxAge")
.version("3.0.0")
.fallbackConf(MAX_LOG_AGE_S)
val HISTORY_SERVER_UI_ACLS_ENABLE = ConfigBuilder("spark.history.ui.acls.enable")
.version("1.0.1")
.booleanConf
.createWithDefault(false)
val HISTORY_SERVER_UI_ADMIN_ACLS = ConfigBuilder("spark.history.ui.admin.acls")
.version("2.1.1")
.stringConf
.toSequence
.createWithDefault(Nil)
val HISTORY_SERVER_UI_ADMIN_ACLS_GROUPS = ConfigBuilder("spark.history.ui.admin.acls.groups")
.version("2.1.1")
.stringConf
.toSequence
.createWithDefault(Nil)
val NUM_REPLAY_THREADS = ConfigBuilder("spark.history.fs.numReplayThreads")
.version("2.0.0")
.intConf
.createWithDefaultFunction(() => Math.ceil(Runtime.getRuntime.availableProcessors() / 4f).toInt)
val RETAINED_APPLICATIONS = ConfigBuilder("spark.history.retainedApplications")
.version("1.0.0")
.intConf
.createWithDefault(50)
val PROVIDER = ConfigBuilder("spark.history.provider")
.version("1.1.0")
.stringConf
.createOptional
val KERBEROS_ENABLED = ConfigBuilder("spark.history.kerberos.enabled")
.version("1.0.1")
.booleanConf
.createWithDefault(false)
val KERBEROS_PRINCIPAL = ConfigBuilder("spark.history.kerberos.principal")
.version("1.0.1")
.stringConf
.createOptional
val KERBEROS_KEYTAB = ConfigBuilder("spark.history.kerberos.keytab")
.version("1.0.1")
.stringConf
.createOptional
val CUSTOM_EXECUTOR_LOG_URL = ConfigBuilder("spark.history.custom.executor.log.url")
.doc("Specifies custom spark executor log url for supporting external log service instead of " +
"using cluster managers' application log urls in the history server. Spark will support " +
"some path variables via patterns which can vary on cluster manager. Please check the " +
"documentation for your cluster manager to see which patterns are supported, if any. " +
"This configuration has no effect on a live application, it only affects the history server.")
.version("3.0.0")
.stringConf
.createOptional
val APPLY_CUSTOM_EXECUTOR_LOG_URL_TO_INCOMPLETE_APP =
ConfigBuilder("spark.history.custom.executor.log.url.applyIncompleteApplication")
.doc("Whether to apply custom executor log url, as specified by " +
s"${CUSTOM_EXECUTOR_LOG_URL.key}, to incomplete application as well. " +
"Even if this is true, this still only affects the behavior of the history server, " +
"not running spark applications.")
.version("3.0.0")
.booleanConf
.createWithDefault(true)
val HYBRID_STORE_ENABLED = ConfigBuilder("spark.history.store.hybridStore.enabled")
.doc("Whether to use HybridStore as the store when parsing event logs. " +
"HybridStore will first write data to an in-memory store and having a background thread " +
"that dumps data to a disk store after the writing to in-memory store is completed.")
.version("3.1.0")
.booleanConf
.createWithDefault(false)
val MAX_IN_MEMORY_STORE_USAGE = ConfigBuilder("spark.history.store.hybridStore.maxMemoryUsage")
.doc("Maximum memory space that can be used to create HybridStore. The HybridStore co-uses " +
"the heap memory, so the heap memory should be increased through the memory option for SHS " +
"if the HybridStore is enabled.")
.version("3.1.0")
.bytesConf(ByteUnit.BYTE)
.createWithDefaultString("2g")
}
| {'content_hash': 'e19a53358328c8db4d56a1fb8cd5847e', 'timestamp': '', 'source': 'github', 'line_count': 199, 'max_line_length': 100, 'avg_line_length': 39.462311557788944, 'alnum_prop': 0.7059722399083153, 'repo_name': 'ptkool/spark', 'id': 'a6d1c044130f51a220afc01abf83b2bbfacc07f1', 'size': '8653', 'binary': False, 'copies': '11', 'ref': 'refs/heads/master', 'path': 'core/src/main/scala/org/apache/spark/internal/config/History.scala', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'ANTLR', 'bytes': '49912'}, {'name': 'Batchfile', 'bytes': '31352'}, {'name': 'C', 'bytes': '1493'}, {'name': 'CSS', 'bytes': '26836'}, {'name': 'Dockerfile', 'bytes': '9014'}, {'name': 'HTML', 'bytes': '40529'}, {'name': 'HiveQL', 'bytes': '1890736'}, {'name': 'Java', 'bytes': '4138601'}, {'name': 'JavaScript', 'bytes': '203741'}, {'name': 'Makefile', 'bytes': '7776'}, {'name': 'PLSQL', 'bytes': '9439'}, {'name': 'PLpgSQL', 'bytes': '380488'}, {'name': 'PowerShell', 'bytes': '3865'}, {'name': 'Python', 'bytes': '3170742'}, {'name': 'R', 'bytes': '1187040'}, {'name': 'Roff', 'bytes': '36501'}, {'name': 'SQLPL', 'bytes': '9325'}, {'name': 'Scala', 'bytes': '32134649'}, {'name': 'Shell', 'bytes': '204763'}, {'name': 'TSQL', 'bytes': '474884'}, {'name': 'Thrift', 'bytes': '67584'}, {'name': 'q', 'bytes': '79845'}]} |
function [x,f,exitflag,output] = minFunc(funObj,x0,options,varargin)
% [x,f,exitflag,output] = minFunc(funObj,x0,options,varargin)
%
% Unconstrained optimizer using a line search strategy
%
% Uses an interface very similar to fminunc
% (it doesn't support all of the optimization toolbox options,
% but supports many other options).
%
% It computes descent directions using one of ('Method'):
% - 'sd': Steepest Descent
% (no previous information used, not recommended)
% - 'csd': Cyclic Steepest Descent
% (uses previous step length for a fixed length cycle)
% - 'bb': Barzilai and Borwein Gradient
% (uses only previous step)
% - 'cg': Non-Linear Conjugate Gradient
% (uses only previous step and a vector beta)
% - 'scg': Scaled Non-Linear Conjugate Gradient
% (uses previous step and a vector beta,
% and Hessian-vector products to initialize line search)
% - 'pcg': Preconditionined Non-Linear Conjugate Gradient
% (uses only previous step and a vector beta, preconditioned version)
% - 'lbfgs': Quasi-Newton with Limited-Memory BFGS Updating
% (default: uses a predetermined nunber of previous steps to form a
% low-rank Hessian approximation)
% - 'newton0': Hessian-Free Newton
% (numerically computes Hessian-Vector products)
% - 'pnewton0': Preconditioned Hessian-Free Newton
% (numerically computes Hessian-Vector products, preconditioned
% version)
% - 'qnewton': Quasi-Newton Hessian approximation
% (uses dense Hessian approximation)
% - 'mnewton': Newton's method with Hessian calculation after every
% user-specified number of iterations
% (needs user-supplied Hessian matrix)
% - 'newton': Newton's method with Hessian calculation every iteration
% (needs user-supplied Hessian matrix)
% - 'tensor': Tensor
% (needs user-supplied Hessian matrix and Tensor of 3rd partial derivatives)
%
% Several line search strategies are available for finding a step length satisfying
% the termination criteria ('LS_type')
% - 0 : A backtracking line-search based on the Armijo condition (default for 'bb')
% - 1 : A bracekting line-search based on the strong Wolfe conditions (default for all other methods)
% - 2 : The line-search from the Matlab Optimization Toolbox (requires Matlab's linesearch.m to be added to the path)
%
% For the Armijo line-search, several interpolation strategies are available ('LS_interp'):
% - 0 : Step size halving
% - 1 : Polynomial interpolation using new function values
% - 2 : Polynomial interpolation using new function and gradient values (default)
%
% When (LS_interp = 1), the default setting of (LS_multi = 0) uses quadratic interpolation,
% while if (LS_multi = 1) it uses cubic interpolation if more than one point are available.
%
% When (LS_interp = 2), the default setting of (LS_multi = 0) uses cubic interpolation,
% while if (LS_multi = 1) it uses quartic or quintic interpolation if more than one point are available
%
% To use the non-monotonic Armijo condition, set the 'Fref' value to the number of previous function values to store
%
% For the Wolfe line-search, these interpolation strategies are available ('LS_interp'):
% - 0 : Step Size Doubling and Bisection
% - 1 : Cubic interpolation/extrapolation using new function and gradient values (default)
% - 2 : Mixed quadratic/cubic interpolation/extrapolation
%
% Several strategies for choosing the initial step size are avaiable ('LS_init'):
% - 0: Always try an initial step length of 1 (default for all except 'sd' and 'cg')
% (t = 1)
% - 1: Use a step similar to the previous step
% (t = t_old*min(2,g'd/g_old'd_old))
% - 2: Quadratic Initialization using previous function value and new
% function value/gradient (use this if steps tend to be very long, default for 'sd' and 'cg')
% (t = min(1,2*(f-f_old)/g))
% - 3: The minimum between 1 and twice the previous step length
% (t = min(1,2*t)
% - 4: The scaled conjugate gradient step length (may accelerate
% conjugate gradient methods, but requires a Hessian-vector product, default for 'scg')
% (t = g'd/d'Hd)
%
% Inputs:
% funObj - is a function handle
% x0 - is a starting vector;
% options - is a struct containing parameters (defaults are used for non-existent or blank fields)
% varargin{:} - all other arguments are passed as additional arguments to funObj
%
% Outputs:
% x is the minimum value found
% f is the function value at the minimum found
% exitflag returns an exit condition
% output returns a structure with other information
%
% Supported Input Options
% Display - Level of display [ off | final | (iter) | full | excessive ]
% MaxFunEvals - Maximum number of function evaluations allowed (1000)
% MaxIter - Maximum number of iterations allowed (500)
% optTol - Termination tolerance on the first-order optimality (1e-5)
% progTol - Termination tolerance on progress in terms of function/parameter changes (1e-9)
% Method - [ sd | csd | bb | cg | scg | pcg | {lbfgs} | newton0 | pnewton0 |
% qnewton | mnewton | newton | tensor ]
% c1 - Sufficient Decrease for Armijo condition (1e-4)
% c2 - Curvature Decrease for Wolfe conditions (.2 for cg methods, .9 otherwise)
% LS_init - Line Search Initialization - see above (2 for cg/sd, 4 for scg, 0 otherwise)
% Fref - Setting this to a positive integer greater than 1
% will use non-monotone Armijo objective in the line search.
% (20 for bb, 10 for csd, 1 for all others)
% numDiff - [ 0 | 1 | 2] compute derivatives using user-supplied function (0),
% numerically user forward-differencing (1), or numerically using central-differencing (2)
% (default: 0)
% (this option has a different effect for 'newton', see below)
% useComplex - if 1, use complex differentials if computing numerical derivatives
% to get very accurate values (default: 0)
% DerivativeCheck - if 'on', computes derivatives numerically at initial
% point and compares to user-supplied derivative (default: 'off')
% outputFcn - function to run after each iteration (default: []). It
% should have the following interface:
% outputFcn(x,iterationType,i,funEvals,f,t,gtd,g,d,optCond,varargin{:});
% useMex - where applicable, use mex files to speed things up (default: 1)
% t0 - initial step length on first iteration
% (default: 1 if first iteration is Newton-style method, min(1,1/||f'(x0)||_1) if first iteration is gradient-style method)
%
% Method-specific input options:
% newton:
% HessianModify - type of Hessian modification for direct solvers to
% use if the Hessian is not positive definite (default: 0)
% 0: Minimum Euclidean norm s.t. eigenvalues sufficiently large
% (requires eigenvalues on iterations where matrix is not pd)
% 1: Start with (1/2)*||A||_F and increment until Cholesky succeeds
% (an approximation to method 0, does not require eigenvalues)
% 2: Modified LDL factorization
% (only 1 generalized Cholesky factorization done and no eigenvalues required)
% 3: Modified Spectral Decomposition
% (requires eigenvalues)
% 4: Modified Symmetric Indefinite Factorization
% 5: Uses the eigenvector of the smallest eigenvalue as negative
% curvature direction
% cgSolve - use conjugate gradient instead of direct solver (default: 0)
% 0: Direct Solver
% 1: Conjugate Gradient
% 2: Conjugate Gradient with Diagonal Preconditioner
% 3: Conjugate Gradient with LBFGS Preconditioner
% x: Conjugate Graident with Symmetric Successive Over Relaxation
% Preconditioner with parameter x
% (where x is a real number in the range [0,2])
% x: Conjugate Gradient with Incomplete Cholesky Preconditioner
% with drop tolerance -x
% (where x is a real negative number)
% numDiff - compute Hessian numerically
% (default: 0, done with complex differentials if useComplex = 1)
% LS_saveHessiancomp - when on, only computes the Hessian at the
% first and last iteration of the line search (default: 1)
% mnewton:
% HessianIter - number of iterations to use same Hessian (default: 5)
% qnewton:
% initialHessType - scale initial Hessian approximation (default: 1)
% qnUpdate - type of quasi-Newton update (default: 3):
% 0: BFGS
% 1: SR1 (when it is positive-definite, otherwise BFGS)
% 2: Hoshino
% 3: Self-Scaling BFGS
% 4: Oren's Self-Scaling Variable Metric method
% 5: McCormick-Huang asymmetric update
% Damped - use damped BFGS update (default: 1)
% newton0/pnewton0:
% HvFunc - user-supplied function that returns Hessian-vector products
% (by default, these are computed numerically using autoHv)
% HvFunc should have the following interface: HvFunc(v,x,varargin{:})
% useComplex - use a complex perturbation to get high accuracy
% Hessian-vector products (default: 0)
% (the increased accuracy can make the method much more efficient,
% but gradient code must properly support complex inputs)
% useNegCurv - a negative curvature direction is used as the descent
% direction if one is encountered during the cg iterations
% (default: 1)
% precFunc (for pnewton0 only) - user-supplied preconditioner
% (by default, an L-BFGS preconditioner is used)
% precFunc should have the following interfact:
% precFunc(v,x,varargin{:})
% lbfgs:
% Corr - number of corrections to store in memory (default: 100)
% (higher numbers converge faster but use more memory)
% Damped - use damped update (default: 0)
% cg/scg/pcg:
% cgUpdate - type of update (default for cg/scg: 2, default for pcg: 1)
% 0: Fletcher Reeves
% 1: Polak-Ribiere
% 2: Hestenes-Stiefel (not supported for pcg)
% 3: Gilbert-Nocedal
% HvFunc (for scg only)- user-supplied function that returns Hessian-vector
% products
% (by default, these are computed numerically using autoHv)
% HvFunc should have the following interface:
% HvFunc(v,x,varargin{:})
% precFunc (for pcg only) - user-supplied preconditioner
% (by default, an L-BFGS preconditioner is used)
% precFunc should have the following interface:
% precFunc(v,x,varargin{:})
% bb:
% bbType - type of bb step (default: 0)
% 0: min_alpha ||delta_x - alpha delta_g||_2
% 1: min_alpha ||alpha delta_x - delta_g||_2
% 2: Conic BB
% 3: Gradient method with retards
% csd:
% cycle - length of cycle (default: 3)
%
% Supported Output Options
% iterations - number of iterations taken
% funcCount - number of function evaluations
% algorithm - algorithm used
% firstorderopt - first-order optimality
% message - exit message
% trace.funccount - function evaluations after each iteration
% trace.fval - function value after each iteration
%
% Author: Mark Schmidt (2005)
% Web: http://www.di.ens.fr/~mschmidt/Software/minFunc.html
%
% Sources (in order of how much the source material contributes):
% J. Nocedal and S.J. Wright. 1999. "Numerical Optimization". Springer Verlag.
% R. Fletcher. 1987. "Practical Methods of Optimization". Wiley.
% J. Demmel. 1997. "Applied Linear Algebra. SIAM.
% R. Barret, M. Berry, T. Chan, J. Demmel, J. Dongarra, V. Eijkhout, R.
% Pozo, C. Romine, and H. Van der Vost. 1994. "Templates for the Solution of
% Linear Systems: Building Blocks for Iterative Methods". SIAM.
% J. More and D. Thuente. "Line search algorithms with guaranteed
% sufficient decrease". ACM Trans. Math. Softw. vol 20, 286-307, 1994.
% M. Raydan. "The Barzilai and Borwein gradient method for the large
% scale unconstrained minimization problem". SIAM J. Optim., 7, 26-33,
% (1997).
% "Mathematical Optimization". The Computational Science Education
% Project. 1995.
% C. Kelley. 1999. "Iterative Methods for Optimization". Frontiers in
% Applied Mathematics. SIAM.
if nargin < 3
options = [];
end
% Get Parameters
[verbose,verboseI,debug,doPlot,maxFunEvals,maxIter,optTol,progTol,method,...
corrections,c1,c2,LS_init,cgSolve,qnUpdate,cgUpdate,initialHessType,...
HessianModify,Fref,useComplex,numDiff,LS_saveHessianComp,...
Damped,HvFunc,bbType,cycle,...
HessianIter,outputFcn,useMex,useNegCurv,precFunc,...
LS_type,LS_interp,LS_multi,checkGrad,t0] = ...
minFunc_processInputOptions(options);
% Constants
SD = 0;
CSD = 1;
BB = 2;
CG = 3;
PCG = 4;
LBFGS = 5;
QNEWTON = 6;
NEWTON0 = 7;
NEWTON = 8;
TENSOR = 9;
% Initialize
p = length(x0);
d = zeros(p,1);
x = x0;
t = 1;
% If necessary, form numerical differentiation functions
funEvalMultiplier = 1;
if useComplex
numDiffType = 3;
else
numDiffType = numDiff;
end
if numDiff && method ~= TENSOR
varargin(3:end+2) = varargin(1:end);
varargin{1} = numDiffType;
varargin{2} = funObj;
if method ~= NEWTON
if debug
if useComplex
fprintf('Using complex differentials for gradient computation\n');
else
fprintf('Using finite differences for gradient computation\n');
end
end
funObj = @autoGrad;
else
if debug
if useComplex
fprintf('Using complex differentials for Hessian computation\n');
else
fprintf('Using finite differences for Hessian computation\n');
end
end
funObj = @autoHess;
end
if method == NEWTON0 && useComplex == 1
if debug
fprintf('Turning off the use of complex differentials for Hessian-vector products\n');
end
useComplex = 0;
end
if useComplex
funEvalMultiplier = p;
elseif numDiff == 2
funEvalMultiplier = 2*p;
else
funEvalMultiplier = p+1;
end
end
% Evaluate Initial Point
if method < NEWTON
[f,g] = funObj(x,varargin{:});
computeHessian = 0;
else
[f,g,H] = funObj(x,varargin{:});
computeHessian = 1;
end
funEvals = 1;
% Derivative Check
if checkGrad
if numDiff
fprintf('Can not do derivative checking when numDiff is 1\n');
pause
end
derivativeCheck(funObj,x,1,numDiffType,varargin{:}); % Checks gradient
if computeHessian
derivativeCheck(funObj,x,2,numDiffType,varargin{:});
end
end
% Output Log
if verboseI
fprintf('%10s %10s %15s %15s %15s\n','Iteration','FunEvals','Step Length','Function Val','Opt Cond');
end
% Compute optimality of initial point
optCond = max(abs(g));
if nargout > 3
% Initialize Trace
trace.fval = f;
trace.funcCount = funEvals;
trace.optCond = optCond;
end
% Exit if initial point is optimal
if optCond <= optTol
exitflag=1;
msg = 'Optimality Condition below optTol';
if verbose
fprintf('%s\n',msg);
end
if nargout > 3
output = struct('iterations',0,'funcCount',1,...
'algorithm',method,'firstorderopt',max(abs(g)),'message',msg,'trace',trace);
end
return;
end
% Output Function
if ~isempty(outputFcn)
stop = outputFcn(x,'init',0,funEvals,f,[],[],g,[],max(abs(g)),varargin{:});
if stop
exitflag=-1;
msg = 'Stopped by output function';
if verbose
fprintf('%s\n',msg);
end
if nargout > 3
output = struct('iterations',0,'funcCount',1,...
'algorithm',method,'firstorderopt',max(abs(g)),'message',msg,'trace',trace);
end
return;
end
end
% Perform up to a maximum of 'maxIter' descent steps:
for i = 1:maxIter
% ****************** COMPUTE DESCENT DIRECTION *****************
switch method
case SD % Steepest Descent
d = -g;
case CSD % Cyclic Steepest Descent
if mod(i,cycle) == 1 % Use Steepest Descent
alpha = 1;
LS_init = 2;
LS_type = 1; % Wolfe line search
elseif mod(i,cycle) == mod(1+1,cycle) % Use Previous Step
alpha = t;
LS_init = 0;
LS_type = 0; % Armijo line search
end
d = -alpha*g;
case BB % Steepest Descent with Barzilai and Borwein Step Length
if i == 1
d = -g;
tau = .5;
alpha2old = 1;
else
y = g-g_old;
s = t*d;
if bbType == 0
alpha = (s'*y)/(y'*y);
elseif bbType == 1
alpha = (s'*s)/(s'*y);
elseif bbType == 2 % Conic Interpolation ('Modified BB')
ss = s'*s;
alpha = ss/(s'*y);
alphaConic = ss/(6*(myF_old - f) + 4*g'*s + 2*g_old'*s);
if alphaConic > .001*alpha && alphaConic < 1000*alpha
alpha = alphaConic;
end
elseif bbType == 3 % Gradient Method with retards (bb type 1, random selection of previous step)
alpha = (s'*s)/(s'*y);
v(1+mod(i-2,5)) = alpha;
alpha = v(ceil(rand*length(v)));
elseif bbType == 4 % Method that alternates between the two BB step sizes
alpha1 = max(1e-10,min((s'*s)/(s'*y),1e10));
alpha2 = max(1e-10,min((s'*y)/(y'*y),1e10));
if alpha2/alpha1 <= .5
alpha = min(alpha2,alpha2old);
tau = tau*.9;
else
alpha = alpha1;
tau = tau*1.1;
end
alpha2old = alpha2;
end
if alpha <= 1e-10 || alpha > 1e10
if debug
fprintf('Barzilai-Borwein step-size out of reasonable range\n');
end
alpha = 1;
end
d = -alpha*g;
end
g_old = g;
myF_old = f;
case CG % Non-Linear Conjugate Gradient
if i == 1
d = -g; % Initially use steepest descent direction
else
gotgo = g_old'*g_old;
if cgUpdate == 0
% Fletcher-Reeves
beta = (g'*g)/(gotgo);
elseif cgUpdate == 1
% Polak-Ribiere
beta = (g'*(g-g_old)) /(gotgo);
elseif cgUpdate == 2
% Hestenes-Stiefel
beta = (g'*(g-g_old))/((g-g_old)'*d);
else
% Gilbert-Nocedal
beta_FR = (g'*(g-g_old)) /(gotgo);
beta_PR = (g'*g-g'*g_old)/(gotgo);
beta = max(-beta_FR,min(beta_PR,beta_FR));
end
d = -g + beta*d;
% Restart if not a direction of sufficient descent
if g'*d > -progTol
if debug
fprintf('Restarting CG\n');
end
beta = 0;
d = -g;
end
% Old restart rule:
%if beta < 0 || abs(gtgo)/(gotgo) >= 0.1 || g'*d >= 0
end
g_old = g;
case PCG % Preconditioned Non-Linear Conjugate Gradient
% Apply preconditioner to negative gradient
if isempty(precFunc)
% Use L-BFGS Preconditioner
if i == 1
S = zeros(p,corrections);
Y = zeros(p,corrections);
YS = zeros(corrections,1);
lbfgs_start = 1;
lbfgs_end = 0;
Hdiag = 1;
s = -g;
else
[S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,skipped] = lbfgsAdd(g-g_old,t*d,S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,useMex);
if debug && skipped
fprintf('Skipped L-BFGS updated\n');
end
if useMex
s = lbfgsProdC(g,S,Y,YS,int32(lbfgs_start),int32(lbfgs_end),Hdiag);
else
s = lbfgsProd(g,S,Y,YS,lbfgs_start,lbfgs_end,Hdiag);
end
end
else % User-supplied preconditioner
s = precFunc(-g,x,varargin{:});
end
if i == 1
d = s;
else
if cgUpdate == 0
% Preconditioned Fletcher-Reeves
beta = (g'*s)/(g_old'*s_old);
elseif cgUpdate < 3
% Preconditioned Polak-Ribiere
beta = (g'*(s-s_old))/(g_old'*s_old);
else
% Preconditioned Gilbert-Nocedal
beta_FR = (g'*s)/(g_old'*s_old);
beta_PR = (g'*(s-s_old))/(g_old'*s_old);
beta = max(-beta_FR,min(beta_PR,beta_FR));
end
d = s + beta*d;
if g'*d > -progTol
if debug
fprintf('Restarting CG\n');
end
beta = 0;
d = s;
end
end
g_old = g;
s_old = s;
case LBFGS % L-BFGS
% Update the direction and step sizes
if Damped
if i == 1
d = -g; % Initially use steepest descent direction
old_dirs = zeros(length(g),0);
old_stps = zeros(length(d),0);
Hdiag = 1;
else
[old_dirs,old_stps,Hdiag] = dampedUpdate(g-g_old,t*d,corrections,debug,old_dirs,old_stps,Hdiag);
if useMex
d = lbfgsC(-g,old_dirs,old_stps,Hdiag);
else
d = lbfgs(-g,old_dirs,old_stps,Hdiag);
end
end
else
if i == 1
d = -g; % Initially use steepest descent direction
S = zeros(p,corrections);
Y = zeros(p,corrections);
YS = zeros(corrections,1);
lbfgs_start = 1;
lbfgs_end = 0;
Hdiag = 1;
else
[S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,skipped] = lbfgsAdd(g-g_old,t*d,S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,useMex);
if debug && skipped
fprintf('Skipped L-BFGS updated\n');
end
if useMex
d = lbfgsProdC(g,S,Y,YS,int32(lbfgs_start),int32(lbfgs_end),Hdiag);
else
d = lbfgsProd(g,S,Y,YS,lbfgs_start,lbfgs_end,Hdiag);
end
end
end
g_old = g;
case QNEWTON % Use quasi-Newton Hessian approximation
if i == 1
d = -g;
else
% Compute difference vectors
y = g-g_old;
s = t*d;
if i == 2
% Make initial Hessian approximation
if initialHessType == 0
% Identity
if qnUpdate <= 1
R = eye(length(g));
else
H = eye(length(g));
end
else
% Scaled Identity
if debug
fprintf('Scaling Initial Hessian Approximation\n');
end
if qnUpdate <= 1
% Use Cholesky of Hessian approximation
R = sqrt((y'*y)/(y'*s))*eye(length(g));
else
% Use Inverse of Hessian approximation
H = eye(length(g))*(y'*s)/(y'*y);
end
end
end
if qnUpdate == 0 % Use BFGS updates
Bs = R'*(R*s);
if Damped
eta = .02;
if y'*s < eta*s'*Bs
if debug
fprintf('Damped Update\n');
end
theta = min(max(0,((1-eta)*s'*Bs)/(s'*Bs - y'*s)),1);
y = theta*y + (1-theta)*Bs;
end
R = cholupdate(cholupdate(R,y/sqrt(y'*s)),Bs/sqrt(s'*Bs),'-');
else
if y'*s > 1e-10
R = cholupdate(cholupdate(R,y/sqrt(y'*s)),Bs/sqrt(s'*Bs),'-');
else
if debug
fprintf('Skipping Update\n');
end
end
end
elseif qnUpdate == 1 % Perform SR1 Update if it maintains positive-definiteness
Bs = R'*(R*s);
ymBs = y-Bs;
if abs(s'*ymBs) >= norm(s)*norm(ymBs)*1e-8 && (s-((R\(R'\y))))'*y > 1e-10
R = cholupdate(R,-ymBs/sqrt(ymBs'*s),'-');
else
if debug
fprintf('SR1 not positive-definite, doing BFGS Update\n');
end
if Damped
eta = .02;
if y'*s < eta*s'*Bs
if debug
fprintf('Damped Update\n');
end
theta = min(max(0,((1-eta)*s'*Bs)/(s'*Bs - y'*s)),1);
y = theta*y + (1-theta)*Bs;
end
R = cholupdate(cholupdate(R,y/sqrt(y'*s)),Bs/sqrt(s'*Bs),'-');
else
if y'*s > 1e-10
R = cholupdate(cholupdate(R,y/sqrt(y'*s)),Bs/sqrt(s'*Bs),'-');
else
if debug
fprintf('Skipping Update\n');
end
end
end
end
elseif qnUpdate == 2 % Use Hoshino update
v = sqrt(y'*H*y)*(s/(s'*y) - (H*y)/(y'*H*y));
phi = 1/(1 + (y'*H*y)/(s'*y));
H = H + (s*s')/(s'*y) - (H*y*y'*H)/(y'*H*y) + phi*v*v';
elseif qnUpdate == 3 % Self-Scaling BFGS update
ys = y'*s;
Hy = H*y;
yHy = y'*Hy;
gamma = ys/yHy;
v = sqrt(yHy)*(s/ys - Hy/yHy);
H = gamma*(H - Hy*Hy'/yHy + v*v') + (s*s')/ys;
elseif qnUpdate == 4 % Oren's Self-Scaling Variable Metric update
% Oren's method
if (s'*y)/(y'*H*y) > 1
phi = 1; % BFGS
omega = 0;
elseif (s'*(H\s))/(s'*y) < 1
phi = 0; % DFP
omega = 1;
else
phi = (s'*y)*(y'*H*y-s'*y)/((s'*(H\s))*(y'*H*y)-(s'*y)^2);
omega = phi;
end
gamma = (1-omega)*(s'*y)/(y'*H*y) + omega*(s'*(H\s))/(s'*y);
v = sqrt(y'*H*y)*(s/(s'*y) - (H*y)/(y'*H*y));
H = gamma*(H - (H*y*y'*H)/(y'*H*y) + phi*v*v') + (s*s')/(s'*y);
elseif qnUpdate == 5 % McCormick-Huang asymmetric update
theta = 1;
phi = 0;
psi = 1;
omega = 0;
t1 = s*(theta*s + phi*H'*y)';
t2 = (theta*s + phi*H'*y)'*y;
t3 = H*y*(psi*s + omega*H'*y)';
t4 = (psi*s + omega*H'*y)'*y;
H = H + t1/t2 - t3/t4;
end
if qnUpdate <= 1
d = -R\(R'\g);
else
d = -H*g;
end
end
g_old = g;
case NEWTON0 % Hessian-Free Newton
cgMaxIter = min(p,maxFunEvals-funEvals);
cgForce = min(0.5,sqrt(norm(g)))*norm(g);
% Set-up preconditioner
precondFunc = [];
precondArgs = [];
if cgSolve == 1
if isempty(precFunc) % Apply L-BFGS preconditioner
if i == 1
S = zeros(p,corrections);
Y = zeros(p,corrections);
YS = zeros(corrections,1);
lbfgs_start = 1;
lbfgs_end = 0;
Hdiag = 1;
else
[S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,skipped] = lbfgsAdd(g-g_old,t*d,S,Y,YS,lbfgs_start,lbfgs_end,Hdiag,useMex);
if debug && skipped
fprintf('Skipped L-BFGS updated\n');
end
if useMex
precondFunc = @lbfgsProdC;
else
precondFunc = @lbfgsProd;
end
precondArgs = {S,Y,YS,int32(lbfgs_start),int32(lbfgs_end),Hdiag};
end
g_old = g;
else
% Apply user-defined preconditioner
precondFunc = precFunc;
precondArgs = {x,varargin{:}};
end
end
% Solve Newton system using cg and hessian-vector products
if isempty(HvFunc)
% No user-supplied Hessian-vector function,
% use automatic differentiation
HvFun = @autoHv;
HvArgs = {x,g,useComplex,funObj,varargin{:}};
else
% Use user-supplid Hessian-vector function
HvFun = HvFunc;
HvArgs = {x,varargin{:}};
end
if useNegCurv
[d,cgIter,cgRes,negCurv] = conjGrad([],-g,cgForce,cgMaxIter,debug,precondFunc,precondArgs,HvFun,HvArgs);
else
[d,cgIter,cgRes] = conjGrad([],-g,cgForce,cgMaxIter,debug,precondFunc,precondArgs,HvFun,HvArgs);
end
funEvals = funEvals+cgIter;
if debug
fprintf('newtonCG stopped on iteration %d w/ residual %.5e\n',cgIter,cgRes);
end
if useNegCurv
if ~isempty(negCurv)
%if debug
fprintf('Using negative curvature direction\n');
%end
d = negCurv/norm(negCurv);
d = d/sum(abs(g));
end
end
case NEWTON % Newton search direction
if cgSolve == 0
if HessianModify == 0
% Attempt to perform a Cholesky factorization of the Hessian
[R,posDef] = chol(H);
% If the Cholesky factorization was successful, then the Hessian is
% positive definite, solve the system
if posDef == 0
d = -R\(R'\g);
else
% otherwise, adjust the Hessian to be positive definite based on the
% minimum eigenvalue, and solve with QR
% (expensive, we don't want to do this very much)
if debug
fprintf('Adjusting Hessian\n');
end
H = H + eye(length(g)) * max(0,1e-12 - min(real(eig(H))));
d = -H\g;
end
elseif HessianModify == 1
% Modified Incomplete Cholesky
R = mcholinc(H,debug);
d = -R\(R'\g);
elseif HessianModify == 2
% Modified Generalized Cholesky
if useMex
[L D perm] = mcholC(H);
else
[L D perm] = mchol(H);
end
d(perm) = -L' \ ((D.^-1).*(L \ g(perm)));
elseif HessianModify == 3
% Modified Spectral Decomposition
[V,D] = eig((H+H')/2);
D = diag(D);
D = max(abs(D),max(max(abs(D)),1)*1e-12);
d = -V*((V'*g)./D);
elseif HessianModify == 4
% Modified Symmetric Indefinite Factorization
[L,D,perm] = ldl(H,'vector');
[blockPos junk] = find(triu(D,1));
for diagInd = setdiff(setdiff(1:p,blockPos),blockPos+1)
if D(diagInd,diagInd) < 1e-12
D(diagInd,diagInd) = 1e-12;
end
end
for blockInd = blockPos'
block = D(blockInd:blockInd+1,blockInd:blockInd+1);
block_a = block(1);
block_b = block(2);
block_d = block(4);
lambda = (block_a+block_d)/2 - sqrt(4*block_b^2 + (block_a - block_d)^2)/2;
D(blockInd:blockInd+1,blockInd:blockInd+1) = block+eye(2)*(lambda+1e-12);
end
d(perm) = -L' \ (D \ (L \ g(perm)));
else
% Take Newton step if Hessian is pd,
% otherwise take a step with negative curvature
[R,posDef] = chol(H);
if posDef == 0
d = -R\(R'\g);
else
if debug
fprintf('Taking Direction of Negative Curvature\n');
end
[V,D] = eig(H);
u = V(:,1);
d = -sign(u'*g)*u;
end
end
else
% Solve with Conjugate Gradient
cgMaxIter = p;
cgForce = min(0.5,sqrt(norm(g)))*norm(g);
% Select Preconditioner
if cgSolve == 1
% No preconditioner
precondFunc = [];
precondArgs = [];
elseif cgSolve == 2
% Diagonal preconditioner
precDiag = diag(H);
precDiag(precDiag < 1e-12) = 1e-12 - min(precDiag);
precondFunc = @precondDiag;
precondArgs = {precDiag.^-1};
elseif cgSolve == 3
% L-BFGS preconditioner
if i == 1
old_dirs = zeros(length(g),0);
old_stps = zeros(length(g),0);
Hdiag = 1;
else
[old_dirs,old_stps,Hdiag] = lbfgsUpdate(g-g_old,t*d,corrections,debug,old_dirs,old_stps,Hdiag);
end
g_old = g;
if useMex
precondFunc = @lbfgsC;
else
precondFunc = @lbfgs;
end
precondArgs = {old_dirs,old_stps,Hdiag};
elseif cgSolve > 0
% Symmetric Successive Overelaxation Preconditioner
omega = cgSolve;
D = diag(H);
D(D < 1e-12) = 1e-12 - min(D);
precDiag = (omega/(2-omega))*D.^-1;
precTriu = diag(D/omega) + triu(H,1);
precondFunc = @precondTriuDiag;
precondArgs = {precTriu,precDiag.^-1};
else
% Incomplete Cholesky Preconditioner
opts.droptol = -cgSolve;
opts.rdiag = 1;
R = cholinc(sparse(H),opts);
if min(diag(R)) < 1e-12
R = cholinc(sparse(H + eye*(1e-12 - min(diag(R)))),opts);
end
precondFunc = @precondTriu;
precondArgs = {R};
end
% Run cg with the appropriate preconditioner
if isempty(HvFunc)
% No user-supplied Hessian-vector function
[d,cgIter,cgRes] = conjGrad(H,-g,cgForce,cgMaxIter,debug,precondFunc,precondArgs);
else
% Use user-supplied Hessian-vector function
[d,cgIter,cgRes] = conjGrad(H,-g,cgForce,cgMaxIter,debug,precondFunc,precondArgs,HvFunc,{x,varargin{:}});
end
if debug
fprintf('CG stopped after %d iterations w/ residual %.5e\n',cgIter,cgRes);
%funEvals = funEvals + cgIter;
end
end
case TENSOR % Tensor Method
if numDiff
% Compute 3rd-order Tensor Numerically
[junk1 junk2 junk3 T] = autoTensor(x,numDiffType,funObj,varargin{:});
else
% Use user-supplied 3rd-derivative Tensor
[junk1 junk2 junk3 T] = funObj(x,varargin{:});
end
options_sub.Method = 'newton';
options_sub.Display = 'none';
options_sub.progTol = progTol;
options_sub.optTol = optTol;
d = minFunc(@taylorModel,zeros(p,1),options_sub,f,g,H,T);
if any(abs(d) > 1e5) || all(abs(d) < 1e-5) || g'*d > -progTol
if debug
fprintf('Using 2nd-Order Step\n');
end
[V,D] = eig((H+H')/2);
D = diag(D);
D = max(abs(D),max(max(abs(D)),1)*1e-12);
d = -V*((V'*g)./D);
else
if debug
fprintf('Using 3rd-Order Step\n');
end
end
end
if ~isLegal(d)
fprintf('Step direction is illegal!\n');
pause;
return
end
% ****************** COMPUTE STEP LENGTH ************************
% Directional Derivative
gtd = g'*d;
% Check that progress can be made along direction
if gtd > -progTol
exitflag=2;
msg = 'Directional Derivative below progTol';
break;
end
% Select Initial Guess
if i == 1
if isempty(t0)
if method < NEWTON0
t = min(1,1/sum(abs(g)));
else
t = 1;
end
else
t = t0;
end
else
if LS_init == 0
% Newton step
t = 1;
elseif LS_init == 1
% Close to previous step length
t = t*min(2,(gtd_old)/(gtd));
elseif LS_init == 2
% Quadratic Initialization based on {f,g} and previous f
t = min(1,2*(f-f_old)/(gtd));
elseif LS_init == 3
% Double previous step length
t = min(1,t*2);
elseif LS_init == 4
% Scaled step length if possible
if isempty(HvFunc)
% No user-supplied Hessian-vector function,
% use automatic differentiation
dHd = d'*autoHv(d,x,g,0,funObj,varargin{:});
else
% Use user-supplid Hessian-vector function
dHd = d'*HvFunc(d,x,varargin{:});
end
funEvals = funEvals + 1;
if dHd > 0
t = -gtd/(dHd);
else
t = min(1,2*(f-f_old)/(gtd));
end
end
if t <= 0
t = 1;
end
end
f_old = f;
gtd_old = gtd;
% Compute reference fr if using non-monotone objective
if Fref == 1
fr = f;
else
if i == 1
old_fvals = repmat(-inf,[Fref 1]);
end
if i <= Fref
old_fvals(i) = f;
else
old_fvals = [old_fvals(2:end);f];
end
fr = max(old_fvals);
end
computeHessian = 0;
if method >= NEWTON
if HessianIter == 1
computeHessian = 1;
elseif i > 1 && mod(i-1,HessianIter) == 0
computeHessian = 1;
end
end
% Line Search
f_old = f;
if LS_type == 0 % Use Armijo Bactracking
% Perform Backtracking line search
if computeHessian
[t,x,f,g,LSfunEvals,H] = ArmijoBacktrack(x,t,d,f,fr,g,gtd,c1,LS_interp,LS_multi,progTol,debug,doPlot,LS_saveHessianComp,funObj,varargin{:});
else
[t,x,f,g,LSfunEvals] = ArmijoBacktrack(x,t,d,f,fr,g,gtd,c1,LS_interp,LS_multi,progTol,debug,doPlot,1,funObj,varargin{:});
end
funEvals = funEvals + LSfunEvals;
elseif LS_type == 1 % Find Point satisfying Wolfe conditions
if computeHessian
[t,f,g,LSfunEvals,H] = WolfeLineSearch(x,t,d,f,g,gtd,c1,c2,LS_interp,LS_multi,25,progTol,debug,doPlot,LS_saveHessianComp,funObj,varargin{:});
else
[t,f,g,LSfunEvals] = WolfeLineSearch(x,t,d,f,g,gtd,c1,c2,LS_interp,LS_multi,25,progTol,debug,doPlot,1,funObj,varargin{:});
end
funEvals = funEvals + LSfunEvals;
x = x + t*d;
else
% Use Matlab optim toolbox line search
[t,f_new,g_new,LSexitFlag,LSiter]=...
lineSearch({'fungrad',[],funObj},x,p,d,f,gtd,t,c1,c2,-inf,maxFunEvals-funEvals,...
progTol,[],struct('xRows',p,'xCols',1),g,varargin{:});
funEvals = funEvals + LSiter;
if isempty(t)
exitflag = -2;
msg = 'Matlab LineSearch failed';
break;
end
if method >= NEWTON
[f_new,g_new,H] = funObj(x + t*d,varargin{:});
funEvals = funEvals + 1;
end
x = x + t*d;
f = f_new;
g = g_new;
end
% Compute Optimality Condition
optCond = max(abs(g));
% Output iteration information
if verboseI
fprintf('%10d %10d %15.5e %15.5e %15.5e\n',i,funEvals*funEvalMultiplier,t,f,optCond);
end
if nargout > 3
% Update Trace
trace.fval(end+1,1) = f;
trace.funcCount(end+1,1) = funEvals;
trace.optCond(end+1,1) = optCond;
end
% Output Function
if ~isempty(outputFcn)
stop = outputFcn(x,'iter',i,funEvals,f,t,gtd,g,d,optCond,varargin{:});
if stop
exitflag=-1;
msg = 'Stopped by output function';
break;
end
end
% Check Optimality Condition
if optCond <= optTol
exitflag=1;
msg = 'Optimality Condition below optTol';
break;
end
% ******************* Check for lack of progress *******************
if max(abs(t*d)) <= progTol
exitflag=2;
msg = 'Step Size below progTol';
break;
end
if abs(f-f_old) < progTol
exitflag=2;
msg = 'Function Value changing by less than progTol';
break;
end
% ******** Check for going over iteration/evaluation limit *******************
if funEvals*funEvalMultiplier >= maxFunEvals
exitflag = 0;
msg = 'Reached Maximum Number of Function Evaluations';
break;
end
if i == maxIter
exitflag = 0;
msg='Reached Maximum Number of Iterations';
break;
end
end
if verbose
fprintf('%s\n',msg);
end
if nargout > 3
output = struct('iterations',i,'funcCount',funEvals*funEvalMultiplier,...
'algorithm',method,'firstorderopt',max(abs(g)),'message',msg,'trace',trace);
end
% Output Function
if ~isempty(outputFcn)
outputFcn(x,'done',i,funEvals,f,t,gtd,g,d,max(abs(g)),varargin{:});
end
end
| {'content_hash': '2e2f8406ccc53d21ff2e054c65d2a98e', 'timestamp': '', 'source': 'github', 'line_count': 1178, 'max_line_length': 153, 'avg_line_length': 36.61969439728353, 'alnum_prop': 0.514604293198572, 'repo_name': 'TWOEARS/identification-training-pipeline', 'id': 'cb88a119ea3b26afcc63727019d6c031c3e1ad25', 'size': '43138', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'third_party_software/markSchmidt/minFunc/minFunc.m', 'mode': '33188', 'license': 'bsd-2-clause', 'language': [{'name': 'C', 'bytes': '160380'}, {'name': 'C++', 'bytes': '158056'}, {'name': 'FORTRAN', 'bytes': '598090'}, {'name': 'HTML', 'bytes': '83380'}, {'name': 'Java', 'bytes': '100316'}, {'name': 'M', 'bytes': '2031'}, {'name': 'M4', 'bytes': '62711'}, {'name': 'Makefile', 'bytes': '6946'}, {'name': 'Mathematica', 'bytes': '518'}, {'name': 'Matlab', 'bytes': '1324630'}, {'name': 'Python', 'bytes': '58126'}]} |
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_selected="true" android:drawable="@drawable/page_now"/>
<item android:state_selected="false" android:drawable="@drawable/page"/>
</selector> | {'content_hash': 'accf86b7a506715e58558a596bbf6074', 'timestamp': '', 'source': 'github', 'line_count': 5, 'max_line_length': 79, 'avg_line_length': 55.4, 'alnum_prop': 0.7220216606498195, 'repo_name': 's21vwy/CpdNews_for_android6.x', 'id': 'ed8c5b2a970af31284e1bc8b8344faeac1bf55ca', 'size': '277', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'app/src/main/res/drawable/splash_dot.xml', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Java', 'bytes': '5154'}]} |
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
#include <stdarg.h> // variable argument lists
void log_message(char *filename, const char* format, ...) {
FILE *logfile;
logfile = fopen(filename, "a");
if (!logfile) return;
va_list list;
va_start( list, format );
vfprintf(logfile, format, list);
va_end( list );
fprintf(logfile, "\n");
fclose(logfile);
}
int main(int argc, char *argv[]) {
fprintf(stdout, "Initiating daemon...\n");
/* Our process ID and Session ID */
pid_t pid, sid;
/* Fork off the parent process */
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0) {
printf("Daemon forked.\n");
exit(EXIT_SUCCESS);
}
/* Change the file mode mask */
umask(0);
/* Open any logs here */
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Change the current working directory */
if ((chdir("/")) < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* Daemon-specific initialization goes here */
/* Create directory if it does not exist */
struct stat st = {0};
if (stat("/tmp/bora", &st) == -1) {
mkdir("/tmp/bora", 0755);
}
char* filename = "/tmp/bora/gbsd.log";
int daemon_pid = getpid();
int uptime = 0;
/* The Big Loop */
while (1) {
log_message(filename, "Daemon PID: %d, Uptime: %d s", daemon_pid, uptime++);
sleep(1);
}
exit(EXIT_SUCCESS);
}
// Daemon skeleton code source: http://www.netzmafia.de/skripten/unix/linux-daemon-howto.html | {'content_hash': '88a7b6e7666c558c2070e70e0b11f5f5', 'timestamp': '', 'source': 'github', 'line_count': 87, 'max_line_length': 93, 'avg_line_length': 21.402298850574713, 'alnum_prop': 0.6203007518796992, 'repo_name': 'boraozgen/os1617-group4', 'id': 'de7979dbee43208ec0cff4cb0e282beb351fa6ac', 'size': '1862', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'gbs-ws1617/daemon/gbsd.c', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '31486'}, {'name': 'C++', 'bytes': '1210'}, {'name': 'Makefile', 'bytes': '813'}]} |
FROM docs/base:hugo-github-linking
MAINTAINER Mary Anthony <[email protected]> (@moxiegirl)
RUN svn checkout https://github.com/docker/compose/trunk/docs /docs/content/compose
RUN svn checkout https://github.com/docker/swarm/trunk/docs /docs/content/swarm
RUN svn checkout https://github.com/docker/machine/trunk/docs /docs/content/machine
RUN svn checkout https://github.com/docker/distribution/trunk/docs /docs/content/registry
RUN svn checkout https://github.com/kitematic/kitematic/trunk/docs /docs/content/kitematic
RUN svn checkout https://github.com/docker/tutorials/trunk/docs /docs/content/
RUN svn checkout https://github.com/docker/opensource/trunk/docs /docs/content/opensource
# To get the git info for this repo
COPY . /src
COPY . /docs/content/engine
| {'content_hash': '0bb5bfad2816d856e7cc60115d8ac078', 'timestamp': '', 'source': 'github', 'line_count': 15, 'max_line_length': 90, 'avg_line_length': 51.13333333333333, 'alnum_prop': 0.7979139504563233, 'repo_name': 'bogdangrigg/docker', 'id': '51e792523cc5ef6a090f55c36de39e118508708a', 'size': '767', 'binary': False, 'copies': '13', 'ref': 'refs/heads/master', 'path': 'docs/Dockerfile', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Go', 'bytes': '3850008'}, {'name': 'Makefile', 'bytes': '4599'}, {'name': 'Shell', 'bytes': '233248'}, {'name': 'VimL', 'bytes': '1328'}]} |
#if !defined(FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP)
#define FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP
#include "fit_device_settings_mesg.hpp"
namespace fit
{
class DeviceSettingsMesgListener
{
public:
virtual ~DeviceSettingsMesgListener() {}
virtual void OnMesg(DeviceSettingsMesg& mesg) = 0;
};
} // namespace fit
#endif // !defined(FIT_DEVICE_SETTINGS_MESG_LISTENER_HPP)
| {'content_hash': '9342eaa360c09c445637125c0e8dfeb8', 'timestamp': '', 'source': 'github', 'line_count': 20, 'max_line_length': 57, 'avg_line_length': 20.2, 'alnum_prop': 0.7128712871287128, 'repo_name': 'fousa/trackkit', 'id': 'f52d683cb7ee71b46b514998f008f95d740d2c98', 'size': '1374', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'Fit/Fit/FitSDK/fit_device_settings_mesg_listener.hpp', 'mode': '33261', 'license': 'mit', 'language': [{'name': 'C++', 'bytes': '2712000'}, {'name': 'Objective-C', 'bytes': '18265'}, {'name': 'Objective-C++', 'bytes': '72820'}, {'name': 'Ruby', 'bytes': '3495'}, {'name': 'Shell', 'bytes': '3588'}, {'name': 'Swift', 'bytes': '241231'}]} |
using Mcg.System;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.WindowsRuntime;
[assembly: global::System.Runtime.InteropServices.McgGeneratedAssembly]
[assembly: global::System.Runtime.CompilerServices.IgnoresAccessChecksTo("System.Runtime.WindowsRuntime")]
[assembly: global::System.Runtime.CompilerServices.IgnoresAccessChecksTo("System.Net.Http")]
[assembly: global::System.Runtime.CompilerServices.IgnoresAccessChecksTo("System.Text.Encoding.CodePages")]
[assembly: global::System.Runtime.CompilerServices.IgnoresAccessChecksTo("System.IO.FileSystem")]
[assembly: global::System.Runtime.CompilerServices.IgnoresAccessChecksTo("System.Threading.Overlapped")]
// -----------------------------------------------------------------------------------------------------------
//
// WARNING: THIS SOURCE FILE IS FOR 64-BIT BUILDS ONLY!
//
// MCG GENERATED CODE
//
// This C# source file is generated by MCG and is added into the application at compile time to support interop features.
//
// It has three primary components:
//
// 1. Public type definitions with interop implementation used by this application including WinRT & COM data structures and P/Invokes.
//
// 2. The 'McgInterop' class containing marshaling code that acts as a bridge from managed code to native code.
//
// 3. The 'McgNative' class containing marshaling code and native type definitions that call into native code and are called by native code.
//
// -----------------------------------------------------------------------------------------------------------
//
// warning CS0067: The event 'event' is never used
#pragma warning disable 67
// warning CS0169: The field 'field' is never used
#pragma warning disable 169
// warning CS0649: Field 'field' is never assigned to, and will always have its default value 0
#pragma warning disable 414
// warning CS0414: The private field 'field' is assigned but its value is never used
#pragma warning disable 649
// warning CS1591: Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable 1591
// warning CS0108 'member1' hides inherited member 'member2'. Use the new keyword if hiding was intended.
#pragma warning disable 108
// warning CS0114 'member1' hides inherited member 'member2'. To make the current method override that implementation, add the override keyword. Otherwise add the new keyword.
#pragma warning disable 114
// warning CS0659 'type' overrides Object.Equals but does not override GetHashCode.
#pragma warning disable 659
// warning CS0465 Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?
#pragma warning disable 465
// warning CS0028 'function declaration' has the wrong signature to be an entry point
#pragma warning disable 28
// warning CS0162 Unreachable code Detected
#pragma warning disable 162
// warning CS0628 new protected member declared in sealed class
#pragma warning disable 628
| {'content_hash': 'ecf2030818b1e9552eebf720430261bc', 'timestamp': '', 'source': 'github', 'line_count': 59, 'max_line_length': 176, 'avg_line_length': 52.440677966101696, 'alnum_prop': 0.7375565610859729, 'repo_name': 'limo1996/PiStudio', 'id': 'af97ac87b949b602715bbd2273b883cac04113e5', 'size': '3122', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'PiStudio.Win10/bin/x64/Release/ilc/AssemblyInfo.g.cs', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C#', 'bytes': '49275873'}, {'name': 'HTML', 'bytes': '107202'}, {'name': 'Java', 'bytes': '7396'}, {'name': 'Smalltalk', 'bytes': '155'}]} |
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>is_complete</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
<link rel="prev" href="is_class.html" title="is_class">
<link rel="next" href="is_complex.html" title="is_complex">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_typetraits.reference.is_complete"></a><a class="link" href="is_complete.html" title="is_complete">is_complete</a>
</h3></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">is_complete</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code></em> <span class="special">{};</span>
</pre>
<p>
<span class="bold"><strong>Inherits:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code>
is a complete type then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
</p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
This trait is designed for one use only: to trigger a hard error (via a
<code class="computeroutput"><span class="keyword">static_assert</span></code>) when a template
is accidentally instantiated on an incomplete type. Any other use case
will cause ODR violations as the "completeness" of type <code class="computeroutput"><span class="identifier">T</span></code> may vary at different points in the
current translation unit, as well as across translations units. <span class="emphasis"><em><span class="bold"><strong>In particular this trait should never ever be used to change
code paths depending on the completeness of a type</strong></span></em></span>.
</p></td></tr>
</table></div>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_complete</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 SFINAE-expressions
to function fully. The macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_WORKING_IS_COMPLETE</span></code>
is defined when the trait is fully functional.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
Watanabe<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
| {'content_hash': '12587bcc5eb994e98a416e7e49c9eadb', 'timestamp': '', 'source': 'github', 'line_count': 79, 'max_line_length': 429, 'avg_line_length': 79.92405063291139, 'alnum_prop': 0.6541019955654102, 'repo_name': 'alexhenrie/poedit', 'id': '139d5ea9abd4e09f3e05c7cebbab42d5e4a6ea05', 'size': '6314', 'binary': False, 'copies': '5', 'ref': 'refs/heads/master', 'path': 'deps/boost/libs/type_traits/doc/html/boost_typetraits/reference/is_complete.html', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'C', 'bytes': '48113'}, {'name': 'C++', 'bytes': '1285031'}, {'name': 'Inno Setup', 'bytes': '11180'}, {'name': 'M4', 'bytes': '103958'}, {'name': 'Makefile', 'bytes': '9507'}, {'name': 'Objective-C', 'bytes': '16519'}, {'name': 'Objective-C++', 'bytes': '14681'}, {'name': 'Python', 'bytes': '6594'}, {'name': 'Ruby', 'bytes': '292'}, {'name': 'Shell', 'bytes': '11982'}]} |
<?php defined('SYSPATH') or die('No direct script access.');
class Kohana_HTTP_Exception extends Kohana_Exception {
/**
* @var int http status code
*/
protected $_code = 0;
/**
* Creates a new translated exception.
*
* throw new Kohana_Exception('Something went terrible wrong, :user',
* array(':user' => $user));
*
* @param string $message status message, custom content to display with error
* @param array $variables translation variables
* @param integer $code the http status code
* @return void
*/
public function __construct($message = NULL, array $variables = NULL, $code = 0)
{
if ($code == 0)
{
$code = $this->_code;
}
if ( ! isset(Response::$messages[$code]))
throw new Kohana_Exception('Unrecognized HTTP status code: :code . Only valid HTTP status codes are acceptable, see RFC 2616.', array(':code' => $code));
parent::__construct($message, $variables, $code);
}
} // End Kohana_HTTP_Exception | {'content_hash': '16a5c4f57323458745f61a43d1f55e64', 'timestamp': '', 'source': 'github', 'line_count': 34, 'max_line_length': 156, 'avg_line_length': 29.41176470588235, 'alnum_prop': 0.635, 'repo_name': 'lz1988/stourwebcms', 'id': '8d18ef8f03f0bc9080c57559af9c5e5a4d7986dd', 'size': '1000', 'binary': False, 'copies': '17', 'ref': 'refs/heads/master', 'path': 'newtravel/system/classes/kohana/http/exception.php', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'ApacheConf', 'bytes': '9916'}, {'name': 'Batchfile', 'bytes': '21'}, {'name': 'C++', 'bytes': '130'}, {'name': 'CSS', 'bytes': '2075176'}, {'name': 'HTML', 'bytes': '1662583'}, {'name': 'Java', 'bytes': '14870'}, {'name': 'JavaScript', 'bytes': '4281928'}, {'name': 'PHP', 'bytes': '16925141'}, {'name': 'Shell', 'bytes': '5657'}, {'name': 'SourcePawn', 'bytes': '177'}]} |
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ChangeListManager">
<list default="true" id="de4c061d-dceb-49cf-b36d-56e041c90819" name="Default" comment="" />
<ignored path="ex.iws" />
<ignored path=".idea/workspace.xml" />
<option name="TRACKING_ENABLED" value="true" />
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="ChangesViewManager" flattened_view="true" show_ignored="false" />
<component name="CreatePatchCommitExecutor">
<option name="PATCH_PATH" value="" />
</component>
<component name="DaemonCodeAnalyzer">
<disable_hints />
</component>
<component name="FavoritesManager">
<favorites_list name="ex" />
</component>
<component name="FileEditorManager">
<leaf />
</component>
<component name="FindManager">
<FindUsagesManager>
<setting name="OPEN_NEW_TAB" value="false" />
</FindUsagesManager>
</component>
<component name="IdeDocumentHistory">
<option name="changedFiles">
<list>
<option value="$PROJECT_DIR$/logger.js" />
<option value="$PROJECT_DIR$/ex.js" />
<option value="$PROJECT_DIR$/lib/ex.js" />
<option value="$PROJECT_DIR$/README.md" />
<option value="$PROJECT_DIR$/package.json" />
<option value="$PROJECT_DIR$/app.js" />
<option value="$PROJECT_DIR$/Makefile" />
<option value="$PROJECT_DIR$/lib/index.js" />
</list>
</option>
</component>
<component name="ProjectFrameBounds">
<option name="y" value="22" />
<option name="width" value="1440" />
<option name="height" value="874" />
</component>
<component name="ProjectInspectionProfilesVisibleTreeState">
<entry key="Project Default">
<profile-state>
<expanded-state>
<State>
<id />
</State>
</expanded-state>
</profile-state>
</entry>
</component>
<component name="ProjectLevelVcsManager" settingsEditedManually="false">
<OptionsSetting value="true" id="Add" />
<OptionsSetting value="true" id="Remove" />
<OptionsSetting value="true" id="Checkout" />
<OptionsSetting value="true" id="Update" />
<OptionsSetting value="true" id="Status" />
<OptionsSetting value="true" id="Edit" />
<ConfirmationsSetting value="0" id="Add" />
<ConfirmationsSetting value="0" id="Remove" />
</component>
<component name="ProjectReloadState">
<option name="STATE" value="0" />
</component>
<component name="ProjectView">
<navigator currentView="ProjectPane" proportions="" version="1" splitterProportion="0.5">
<flattenPackages />
<showMembers />
<showModules />
<showLibraryContents ProjectPane="true" />
<hideEmptyPackages />
<abbreviatePackageNames />
<autoscrollToSource />
<autoscrollFromSource />
<sortByType />
</navigator>
<panes>
<pane id="Scope">
<subPane subId="Project Files" />
</pane>
<pane id="ProjectPane">
<subPane>
<PATH>
<PATH_ELEMENT>
<option name="myItemId" value="ex" />
<option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
</PATH_ELEMENT>
</PATH>
</subPane>
</pane>
</panes>
</component>
<component name="PropertiesComponent">
<property name="options.splitter.main.proportions" value="0.3" />
<property name="WebServerToolWindowFactoryState" value="false" />
<property name="options.lastSelected" value="JavaScript.Libraries" />
<property name="options.splitter.details.proportions" value="0.2" />
<property name="options.searchVisible" value="true" />
</component>
<component name="RecentsManager">
<key name="MoveFile.RECENT_KEYS">
<recent name="$PROJECT_DIR$/lib" />
</key>
</component>
<component name="RunManager">
<configuration default="true" type="NodeJSConfigurationType" factoryName="Node JS" working-dir="$PROJECT_DIR$">
<method />
</configuration>
<configuration default="true" type="JavascriptDebugSession" factoryName="Local">
<JSDebuggerConfigurationSettings>
<option name="engineId" />
<option name="fileUrl" />
</JSDebuggerConfigurationSettings>
<method />
</configuration>
<list size="0" />
</component>
<component name="ShelveChangesManager" show_recycled="false" />
<component name="SvnConfiguration" maxAnnotateRevisions="500" myUseAcceleration="nothing" myAutoUpdateAfterCommit="false" cleanupOnStartRun="false">
<option name="USER" value="" />
<option name="PASSWORD" value="" />
<option name="mySSHConnectionTimeout" value="30000" />
<option name="mySSHReadTimeout" value="30000" />
<option name="LAST_MERGED_REVISION" />
<option name="MERGE_DRY_RUN" value="false" />
<option name="MERGE_DIFF_USE_ANCESTRY" value="true" />
<option name="UPDATE_LOCK_ON_DEMAND" value="false" />
<option name="IGNORE_SPACES_IN_MERGE" value="false" />
<option name="DETECT_NESTED_COPIES" value="true" />
<option name="CHECK_NESTED_FOR_QUICK_MERGE" value="false" />
<option name="IGNORE_SPACES_IN_ANNOTATE" value="true" />
<option name="SHOW_MERGE_SOURCES_IN_ANNOTATE" value="true" />
<option name="FORCE_UPDATE" value="false" />
<option name="IGNORE_EXTERNALS" value="false" />
<myIsUseDefaultProxy>false</myIsUseDefaultProxy>
</component>
<component name="TaskManager">
<task active="true" id="Default" summary="Default task">
<created>1344250745321</created>
<updated>1344250745321</updated>
</task>
<servers />
</component>
<component name="ToolWindowManager">
<frame x="0" y="22" width="1440" height="874" extended-state="0" />
<editor active="false" />
<layout>
<window_info id="Changes" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
<window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
<window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.25" sideWeight="0.5" order="1" side_tool="true" content_ui="tabs" />
<window_info id="Project" active="true" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" weight="0.24417783" sideWeight="0.5" order="0" side_tool="false" content_ui="combo" />
<window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.4" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
<window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="true" content_ui="tabs" />
<window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="true" content_ui="tabs" />
<window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
<window_info id="JsTestDriver Server" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
<window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="-1" side_tool="false" content_ui="tabs" />
<window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
<window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
<window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
<window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
<window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
<window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
<window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
</layout>
</component>
<component name="VcsContentAnnotationSettings">
<option name="myLimit" value="2678400000" />
</component>
<component name="VcsManagerConfiguration">
<option name="OFFER_MOVE_TO_ANOTHER_CHANGELIST_ON_PARTIAL_COMMIT" value="true" />
<option name="CHECK_CODE_SMELLS_BEFORE_PROJECT_COMMIT" value="true" />
<option name="CHECK_NEW_TODO" value="true" />
<option name="myTodoPanelSettings">
<value>
<are-packages-shown value="false" />
<are-modules-shown value="false" />
<flatten-packages value="false" />
<is-autoscroll-to-source value="false" />
</value>
</option>
<option name="PERFORM_UPDATE_IN_BACKGROUND" value="true" />
<option name="PERFORM_COMMIT_IN_BACKGROUND" value="true" />
<option name="PERFORM_EDIT_IN_BACKGROUND" value="true" />
<option name="PERFORM_CHECKOUT_IN_BACKGROUND" value="true" />
<option name="PERFORM_ADD_REMOVE_IN_BACKGROUND" value="true" />
<option name="PERFORM_ROLLBACK_IN_BACKGROUND" value="false" />
<option name="CHECK_LOCALLY_CHANGED_CONFLICTS_IN_BACKGROUND" value="false" />
<option name="ENABLE_BACKGROUND_PROCESSES" value="false" />
<option name="CHANGED_ON_SERVER_INTERVAL" value="60" />
<option name="SHOW_ONLY_CHANGED_IN_SELECTION_DIFF" value="true" />
<option name="CHECK_COMMIT_MESSAGE_SPELLING" value="true" />
<option name="DEFAULT_PATCH_EXTENSION" value="patch" />
<option name="SHORT_DIFF_HORISONTALLY" value="true" />
<option name="SHORT_DIFF_EXTRA_LINES" value="2" />
<option name="SOFT_WRAPS_IN_SHORT_DIFF" value="true" />
<option name="INCLUDE_TEXT_INTO_PATCH" value="false" />
<option name="INCLUDE_TEXT_INTO_SHELF" value="false" />
<option name="CREATE_PATCH_EXPAND_DETAILS_DEFAULT" value="true" />
<option name="SHOW_FILE_HISTORY_DETAILS" value="true" />
<option name="SHOW_VCS_ERROR_NOTIFICATIONS" value="true" />
<option name="FORCE_NON_EMPTY_COMMENT" value="false" />
<option name="CLEAR_INITIAL_COMMIT_MESSAGE" value="false" />
<option name="LAST_COMMIT_MESSAGE" />
<option name="MAKE_NEW_CHANGELIST_ACTIVE" value="false" />
<option name="OPTIMIZE_IMPORTS_BEFORE_PROJECT_COMMIT" value="false" />
<option name="CHECK_FILES_UP_TO_DATE_BEFORE_COMMIT" value="false" />
<option name="REFORMAT_BEFORE_PROJECT_COMMIT" value="false" />
<option name="REFORMAT_BEFORE_FILE_COMMIT" value="false" />
<option name="FILE_HISTORY_DIALOG_COMMENTS_SPLITTER_PROPORTION" value="0.8" />
<option name="FILE_HISTORY_DIALOG_SPLITTER_PROPORTION" value="0.5" />
<option name="ACTIVE_VCS_NAME" />
<option name="UPDATE_GROUP_BY_PACKAGES" value="false" />
<option name="UPDATE_GROUP_BY_CHANGELIST" value="false" />
<option name="SHOW_FILE_HISTORY_AS_TREE" value="false" />
<option name="FILE_HISTORY_SPLITTER_PROPORTION" value="0.6" />
</component>
<component name="XDebuggerManager">
<breakpoint-manager />
</component>
<component name="editorHistoryManager">
<entry file="jar://$APPLICATION_HOME_DIR$/plugins/NodeJS/lib/NodeJS.jar!/com/jetbrains/nodejs/library/node_embedded_symbols.js">
<provider selected="true" editor-type-id="text-editor">
<state line="17" column="4" selection-start="364" selection-end="364" vertical-scroll-proportion="0.08539945">
<folding />
</state>
</provider>
</entry>
<entry file="file://$USER_HOME$/Library/Caches/WebIde40/extLibs/nodejs-v0.8.4-src/core-modules-sources/lib/child_process.js">
<provider selected="true" editor-type-id="text-editor">
<state line="647" column="23" selection-start="15857" selection-end="15857" vertical-scroll-proportion="0.20428571">
<folding>
<element signature="n#!!doc" expanded="true" />
</folding>
</state>
</provider>
</entry>
<entry file="file://$USER_HOME$/Library/Caches/WebIde40/extLibs/nodejs-v0.8.4-src/core-modules-sources/lib/cluster.js">
<provider selected="true" editor-type-id="text-editor">
<state line="0" column="0" selection-start="0" selection-end="0" vertical-scroll-proportion="-10.652892">
<folding>
<element signature="n#!!doc" expanded="true" />
</folding>
</state>
</provider>
</entry>
<entry file="file://$USER_HOME$/Library/Caches/WebIde40/extLibs/nodejs-v0.8.4-src/core-modules-sources/lib/http.js">
<provider selected="true" editor-type-id="text-editor">
<state line="439" column="31" selection-start="11953" selection-end="11953" vertical-scroll-proportion="0.011019284">
<folding>
<element signature="n#!!doc" expanded="true" />
</folding>
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/lib/logger.js">
<provider selected="true" editor-type-id="text-editor">
<state line="0" column="26" selection-start="26" selection-end="26" vertical-scroll-proportion="0.0">
<folding />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/README.md">
<provider selected="true" editor-type-id="text-editor">
<state line="0" column="2" selection-start="2" selection-end="2" vertical-scroll-proportion="0.0">
<folding />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/package.json">
<provider selected="true" editor-type-id="text-editor">
<state line="4" column="21" selection-start="103" selection-end="103" vertical-scroll-proportion="0.08264463">
<folding />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/Makefile">
<provider selected="true" editor-type-id="text-editor">
<state line="26" column="19" selection-start="672" selection-end="672" vertical-scroll-proportion="0.5371901">
<folding />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/app.js">
<provider selected="true" editor-type-id="text-editor">
<state line="18" column="19" selection-start="422" selection-end="422" vertical-scroll-proportion="0.37190083">
<folding />
</state>
</provider>
</entry>
<entry file="file://$PROJECT_DIR$/lib/index.js">
<provider selected="true" editor-type-id="text-editor">
<state line="6" column="0" selection-start="108" selection-end="108" vertical-scroll-proportion="0.12396694">
<folding />
</state>
</provider>
</entry>
</component>
</project>
| {'content_hash': '50234fedd8613280593dbd3bc932bfcd', 'timestamp': '', 'source': 'github', 'line_count': 309, 'max_line_length': 226, 'avg_line_length': 52.786407766990294, 'alnum_prop': 0.6536079946048678, 'repo_name': 'motherjones/worldmap', 'id': '6ffb59c27f013c70bfe1a9a52e87b1ebe95c8932', 'size': '16311', 'binary': False, 'copies': '4', 'ref': 'refs/heads/master', 'path': 'node_modules/grunt-gss-pull/node_modules/http/.idea/workspace.xml', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '59153'}, {'name': 'JavaScript', 'bytes': '790685'}, {'name': 'PHP', 'bytes': '3071'}]} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.