text:
<?php

namespace Doctrine\Tests\ORM\Functional\Ticket;

require_once __DIR__ . '/../../../TestInit.php';

/**
 * @group DDC-1430
 */
class DDC1430Test extends \Doctrine\Tests\OrmFunctionalTestCase
{

    protected function setUp()
    {
        parent::setUp();

        try {
            $this->_schemaTool->createSchema(array(
                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC1430Order'),
                $this->_em->getClassMetadata(__NAMESPACE__ . '\DDC1430OrderProduct'),
            ));
            $this->loadFixtures();
        } catch (\Exception $exc) {

        }
    }

    public function testOrderByFields()
    {
        $repository = $this->_em->getRepository(__NAMESPACE__ . '\DDC1430Order');
        $builder    = $repository->createQueryBuilder('o');
        $query      = $builder->select('o.id, o.date, COUNT(p.id) AS p_count')
                        ->leftJoin('o.products', 'p')
                        ->groupBy('o.id, o.date')
                        ->orderBy('o.id')
                        ->getQuery();

        $this->assertEquals('SELECT o.id, o.date, COUNT(p.id) AS p_count FROM Doctrine\Tests\ORM\Functional\Ticket\DDC1430Order o LEFT JOIN o.products p GROUP BY o.id, o.date ORDER BY o.id ASC', $query->getDQL());
        $this->assertEquals('SELECT d0_.order_id AS order_id0, d0_.created_at AS created_at1, COUNT(d1_.id) AS sclr2 FROM DDC1430Order d0_ LEFT JOIN DDC1430OrderProduct d1_ ON d0_.order_id = d1_.order_id GROUP BY d0_.order_id, d0_.created_at ORDER BY d0_.order_id ASC', $query->getSQL());

        $result = $query->getResult();

        $this->assertEquals(2, sizeof($result));

        $this->assertArrayHasKey('id', $result[0]);
        $this->assertArrayHasKey('id', $result[1]);

        $this->assertArrayHasKey('p_count', $result[0]);
        $this->assertArrayHasKey('p_count', $result[1]);

        $this->assertEquals(1, $result[0]['id']);
        $this->assertEquals(2, $result[1]['id']);

        $this->assertEquals(2, $result[0]['p_count']);
        $this->assertEquals(3, $result[1]['p_count']);
    }

    public function testOrderByAllObjectFields()
    {
        $repository = $this->_em->getRepository(__NAMESPACE__ . '\DDC1430Order');
        $builder    = $repository->createQueryBuilder('o');
        $query      = $builder->select('o, COUNT(p.id) AS p_count')
                        ->leftJoin('o.products', 'p')
                        ->groupBy('o.id, o.date, o.status')
                        ->orderBy('o.id')
                        ->getQuery();

        $this->assertEquals('SELECT o, COUNT(p.id) AS p_count FROM Doctrine\Tests\ORM\Functional\Ticket\DDC1430Order o LEFT JOIN o.products p GROUP BY o.id, o.date, o.status ORDER BY o.id ASC', $query->getDQL());
        $this->assertEquals('SELECT d0_.order_id AS order_id0, d0_.created_at AS created_at1, d0_.order_status AS order_status2, COUNT(d1_.id) AS sclr3 FROM DDC1430Order d0_ LEFT JOIN DDC1430OrderProduct d1_ ON d0_.order_id = d1_.order_id GROUP BY d0_.order_id, d0_.created_at, d0_.order_status ORDER BY d0_.order_id ASC', $query->getSQL());

        $result = $query->getResult();

        $this->assertEquals(2, sizeof($result));

        $this->assertTrue($result[0][0] instanceof DDC1430Order);
        $this->assertTrue($result[1][0] instanceof DDC1430Order);

        $this->assertEquals($result[0][0]->getId(), 1);
        $this->assertEquals($result[1][0]->getId(), 2);

        $this->assertEquals($result[0]['p_count'], 2);
        $this->assertEquals($result[1]['p_count'], 3);
    }

    public function testTicket()
    {
        $repository = $this->_em->getRepository(__NAMESPACE__ . '\DDC1430Order');
        $builder    = $repository->createQueryBuilder('o');
        $query      = $builder->select('o, COUNT(p.id) AS p_count')
                        ->leftJoin('o.products', 'p')
                        ->groupBy('o')
                        ->orderBy('o.id')
                        ->getQuery();

        $this->assertEquals('SELECT o, COUNT(p.id) AS p_count FROM Doctrine\Tests\ORM\Functional\Ticket\DDC1430Order o LEFT JOIN o.products p GROUP BY o ORDER BY o.id ASC', $query->getDQL());
        $this->assertEquals('SELECT d0_.order_id AS order_id0, d0_.created_at AS created_at1, d0_.order_status AS order_status2, COUNT(d1_.id) AS sclr3 FROM DDC1430Order d0_ LEFT JOIN DDC1430OrderProduct d1_ ON d0_.order_id = d1_.order_id GROUP BY d0_.order_id, d0_.created_at, d0_.order_status ORDER BY d0_.order_id ASC', $query->getSQL());

        $result = $query->getResult();

        $this->assertEquals(2, sizeof($result));

        $this->assertTrue($result[0][0] instanceof DDC1430Order);
        $this->assertTrue($result[1][0] instanceof DDC1430Order);

        $this->assertEquals($result[0][0]->getId(), 1);
        $this->assertEquals($result[1][0]->getId(), 2);

        $this->assertEquals($result[0]['p_count'], 2);
        $this->assertEquals($result[1]['p_count'], 3);
    }

    public function loadFixtures()
    {
        $o1 = new DDC1430Order('NEW');
        $o2 = new DDC1430Order('OK');

        $o1->addProduct(new DDC1430OrderProduct(1.1));
        $o1->addProduct(new DDC1430OrderProduct(1.2));

        $o2->addProduct(new DDC1430OrderProduct(2.1));
        $o2->addProduct(new DDC1430OrderProduct(2.2));
        $o2->addProduct(new DDC1430OrderProduct(2.3));

        $this->_em->persist($o1);
        $this->_em->persist($o2);

        $this->_em->flush();
    }

}

/**
 * @Entity
 */
class DDC1430Order
{

    /**
     * @Id
     * @Column(name="order_id", type="integer")
     * @GeneratedValue()
     */
    protected $id;

    /**
     * @Column(name="created_at", type="datetime")
     */
    private $date;

    /**
     * @Column(name="order_status", type="string")
     */
    private $status;

    /**
     * @OneToMany(targetEntity="DDC1430OrderProduct", mappedBy="order", cascade={"persist", "remove"})
     *
     * @var \Doctrine\Common\Collections\ArrayCollection $products
     */
    private $products;

    /**
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    public function __construct($status)
    {
        $this->status   = $status;
        $this->date     = new \DateTime();
        $this->products = new \Doctrine\Common\Collections\ArrayCollection();
    }
    /**
     * @return \DateTime
     */
    public function getDate()
    {
        return $this->date;
    }

    /**
     * @return string
     */
    public function getStatus()
    {
        return $this->status;
    }

    /**
     * @param string $status
     */
    public function setStatus($status)
    {
        $this->status = $status;
    }

    /**
     * @return \Doctrine\Common\Collections\ArrayCollection
     */
    public function getProducts()
    {
        return $this->products;
    }

    /**
     * @param DDC1430OrderProduct $product
     */
    public function addProduct(DDC1430OrderProduct $product)
    {
        $product->setOrder($this);
        $this->products->add($product);
    }
}

/**
 * @Entity
 */
class DDC1430OrderProduct
{

     /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue()
     */
    protected $id;

    /**
     * @var DDC1430Order $order
     *
     * @ManyToOne(targetEntity="DDC1430Order", inversedBy="products")
     * @JoinColumn(name="order_id", referencedColumnName="order_id", nullable = false)
     */
    private $order;

    /**
     * @column(type="float")
     */
    private $value;

    /**
     * @param float $value
     */
    public function __construct($value)
    {
        $this->value = $value;
    }

     /**
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return DDC1430Order
     */
    public function getOrder()
    {
        return $this->order;
    }

    /**
     * @param DDC1430Order $order
     */
    public function setOrder(DDC1430Order $order)
    {
        $this->order = $order;
    }

    /**
     * @return float
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * @param float $value
     */
    public function setValue($value)
    {
        $this->value = $value;
    }

}


text:
import { BaseResource } from 'ms-rest-azure';
import { CloudError } from 'ms-rest-azure';
import * as moment from 'moment';

export { BaseResource } from 'ms-rest-azure';
export { CloudError } from 'ms-rest-azure';

/**
 * @class
 * Initializes a new instance of the ContainerPort class.
 * @constructor
 * The port exposed on the container instance.
 *
 * @member {string} [protocol] The protocol associated with the port. Possible
 * values include: 'TCP', 'UDP'
 * @member {number} port The port number exposed within the container group.
 */
export interface ContainerPort {
  protocol?: string;
  port: number;
}

/**
 * @class
 * Initializes a new instance of the EnvironmentVariable class.
 * @constructor
 * The environment variable to set within the container instance.
 *
 * @member {string} name The name of the environment variable.
 * @member {string} [value] The value of the environment variable.
 * @member {string} [secureValue] The value of the secure environment variable.
 */
export interface EnvironmentVariable {
  name: string;
  value?: string;
  secureValue?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerState class.
 * @constructor
 * The container instance state.
 *
 * @member {string} [state] The state of the container instance.
 * @member {date} [startTime] The date-time when the container instance state
 * started.
 * @member {number} [exitCode] The container instance exit codes correspond to
 * those from the `docker run` command.
 * @member {date} [finishTime] The date-time when the container instance state
 * finished.
 * @member {string} [detailStatus] The human-readable status of the container
 * instance state.
 */
export interface ContainerState {
  state?: string;
  startTime?: Date;
  exitCode?: number;
  finishTime?: Date;
  detailStatus?: string;
}

/**
 * @class
 * Initializes a new instance of the Event class.
 * @constructor
 * A container group or container instance event.
 *
 * @member {number} [count] The count of the event.
 * @member {date} [firstTimestamp] The date-time of the earliest logged event.
 * @member {date} [lastTimestamp] The date-time of the latest logged event.
 * @member {string} [name] The event name.
 * @member {string} [message] The event message.
 * @member {string} [type] The event type.
 */
export interface Event {
  count?: number;
  firstTimestamp?: Date;
  lastTimestamp?: Date;
  name?: string;
  message?: string;
  type?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerPropertiesInstanceView class.
 * @constructor
 * The instance view of the container instance. Only valid in response.
 *
 * @member {number} [restartCount] The number of times that the container
 * instance has been restarted.
 * @member {object} [currentState] Current container instance state.
 * @member {string} [currentState.state] The state of the container instance.
 * @member {date} [currentState.startTime] The date-time when the container
 * instance state started.
 * @member {number} [currentState.exitCode] The container instance exit codes
 * correspond to those from the `docker run` command.
 * @member {date} [currentState.finishTime] The date-time when the container
 * instance state finished.
 * @member {string} [currentState.detailStatus] The human-readable status of
 * the container instance state.
 * @member {object} [previousState] Previous container instance state.
 * @member {string} [previousState.state] The state of the container instance.
 * @member {date} [previousState.startTime] The date-time when the container
 * instance state started.
 * @member {number} [previousState.exitCode] The container instance exit codes
 * correspond to those from the `docker run` command.
 * @member {date} [previousState.finishTime] The date-time when the container
 * instance state finished.
 * @member {string} [previousState.detailStatus] The human-readable status of
 * the container instance state.
 * @member {array} [events] The events of the container instance.
 */
export interface ContainerPropertiesInstanceView {
  readonly restartCount?: number;
  readonly currentState?: ContainerState;
  readonly previousState?: ContainerState;
  readonly events?: Event[];
}

/**
 * @class
 * Initializes a new instance of the GpuResource class.
 * @constructor
 * The GPU resource.
 *
 * @member {number} count The count of the GPU resource.
 * @member {string} sku The SKU of the GPU resource. Possible values include:
 * 'K80', 'P100', 'V100'
 */
export interface GpuResource {
  count: number;
  sku: string;
}

/**
 * @class
 * Initializes a new instance of the ResourceRequests class.
 * @constructor
 * The resource requests.
 *
 * @member {number} memoryInGB The memory request in GB of this container
 * instance.
 * @member {number} cpu The CPU request of this container instance.
 * @member {object} [gpu] The GPU request of this container instance.
 * @member {number} [gpu.count] The count of the GPU resource.
 * @member {string} [gpu.sku] The SKU of the GPU resource. Possible values
 * include: 'K80', 'P100', 'V100'
 */
export interface ResourceRequests {
  memoryInGB: number;
  cpu: number;
  gpu?: GpuResource;
}

/**
 * @class
 * Initializes a new instance of the ResourceLimits class.
 * @constructor
 * The resource limits.
 *
 * @member {number} [memoryInGB] The memory limit in GB of this container
 * instance.
 * @member {number} [cpu] The CPU limit of this container instance.
 * @member {object} [gpu] The GPU limit of this container instance.
 * @member {number} [gpu.count] The count of the GPU resource.
 * @member {string} [gpu.sku] The SKU of the GPU resource. Possible values
 * include: 'K80', 'P100', 'V100'
 */
export interface ResourceLimits {
  memoryInGB?: number;
  cpu?: number;
  gpu?: GpuResource;
}

/**
 * @class
 * Initializes a new instance of the ResourceRequirements class.
 * @constructor
 * The resource requirements.
 *
 * @member {object} requests The resource requests of this container instance.
 * @member {number} [requests.memoryInGB] The memory request in GB of this
 * container instance.
 * @member {number} [requests.cpu] The CPU request of this container instance.
 * @member {object} [requests.gpu] The GPU request of this container instance.
 * @member {number} [requests.gpu.count] The count of the GPU resource.
 * @member {string} [requests.gpu.sku] The SKU of the GPU resource. Possible
 * values include: 'K80', 'P100', 'V100'
 * @member {object} [limits] The resource limits of this container instance.
 * @member {number} [limits.memoryInGB] The memory limit in GB of this
 * container instance.
 * @member {number} [limits.cpu] The CPU limit of this container instance.
 * @member {object} [limits.gpu] The GPU limit of this container instance.
 * @member {number} [limits.gpu.count] The count of the GPU resource.
 * @member {string} [limits.gpu.sku] The SKU of the GPU resource. Possible
 * values include: 'K80', 'P100', 'V100'
 */
export interface ResourceRequirements {
  requests: ResourceRequests;
  limits?: ResourceLimits;
}

/**
 * @class
 * Initializes a new instance of the VolumeMount class.
 * @constructor
 * The properties of the volume mount.
 *
 * @member {string} name The name of the volume mount.
 * @member {string} mountPath The path within the container where the volume
 * should be mounted. Must not contain colon (:).
 * @member {boolean} [readOnly] The flag indicating whether the volume mount is
 * read-only.
 */
export interface VolumeMount {
  name: string;
  mountPath: string;
  readOnly?: boolean;
}

/**
 * @class
 * Initializes a new instance of the ContainerExec class.
 * @constructor
 * The container execution command, for liveness or readiness probe
 *
 * @member {array} [command] The commands to execute within the container.
 */
export interface ContainerExec {
  command?: string[];
}

/**
 * @class
 * Initializes a new instance of the ContainerHttpGet class.
 * @constructor
 * The container Http Get settings, for liveness or readiness probe
 *
 * @member {string} [path] The path to probe.
 * @member {number} port The port number to probe.
 * @member {string} [scheme] The scheme. Possible values include: 'http',
 * 'https'
 */
export interface ContainerHttpGet {
  path?: string;
  port: number;
  scheme?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerProbe class.
 * @constructor
 * The container probe, for liveness or readiness
 *
 * @member {object} [exec] The execution command to probe
 * @member {array} [exec.command] The commands to execute within the container.
 * @member {object} [httpGet] The Http Get settings to probe
 * @member {string} [httpGet.path] The path to probe.
 * @member {number} [httpGet.port] The port number to probe.
 * @member {string} [httpGet.scheme] The scheme. Possible values include:
 * 'http', 'https'
 * @member {number} [initialDelaySeconds] The initial delay seconds.
 * @member {number} [periodSeconds] The period seconds.
 * @member {number} [failureThreshold] The failure threshold.
 * @member {number} [successThreshold] The success threshold.
 * @member {number} [timeoutSeconds] The timeout seconds.
 */
export interface ContainerProbe {
  exec?: ContainerExec;
  httpGet?: ContainerHttpGet;
  initialDelaySeconds?: number;
  periodSeconds?: number;
  failureThreshold?: number;
  successThreshold?: number;
  timeoutSeconds?: number;
}

/**
 * @class
 * Initializes a new instance of the Container class.
 * @constructor
 * A container instance.
 *
 * @member {string} name The user-provided name of the container instance.
 * @member {string} image The name of the image used to create the container
 * instance.
 * @member {array} [command] The commands to execute within the container
 * instance in exec form.
 * @member {array} [ports] The exposed ports on the container instance.
 * @member {array} [environmentVariables] The environment variables to set in
 * the container instance.
 * @member {object} [instanceView] The instance view of the container instance.
 * Only valid in response.
 * @member {number} [instanceView.restartCount] The number of times that the
 * container instance has been restarted.
 * @member {object} [instanceView.currentState] Current container instance
 * state.
 * @member {string} [instanceView.currentState.state] The state of the
 * container instance.
 * @member {date} [instanceView.currentState.startTime] The date-time when the
 * container instance state started.
 * @member {number} [instanceView.currentState.exitCode] The container instance
 * exit codes correspond to those from the `docker run` command.
 * @member {date} [instanceView.currentState.finishTime] The date-time when the
 * container instance state finished.
 * @member {string} [instanceView.currentState.detailStatus] The human-readable
 * status of the container instance state.
 * @member {object} [instanceView.previousState] Previous container instance
 * state.
 * @member {string} [instanceView.previousState.state] The state of the
 * container instance.
 * @member {date} [instanceView.previousState.startTime] The date-time when the
 * container instance state started.
 * @member {number} [instanceView.previousState.exitCode] The container
 * instance exit codes correspond to those from the `docker run` command.
 * @member {date} [instanceView.previousState.finishTime] The date-time when
 * the container instance state finished.
 * @member {string} [instanceView.previousState.detailStatus] The
 * human-readable status of the container instance state.
 * @member {array} [instanceView.events] The events of the container instance.
 * @member {object} resources The resource requirements of the container
 * instance.
 * @member {object} [resources.requests] The resource requests of this
 * container instance.
 * @member {number} [resources.requests.memoryInGB] The memory request in GB of
 * this container instance.
 * @member {number} [resources.requests.cpu] The CPU request of this container
 * instance.
 * @member {object} [resources.requests.gpu] The GPU request of this container
 * instance.
 * @member {number} [resources.requests.gpu.count] The count of the GPU
 * resource.
 * @member {string} [resources.requests.gpu.sku] The SKU of the GPU resource.
 * Possible values include: 'K80', 'P100', 'V100'
 * @member {object} [resources.limits] The resource limits of this container
 * instance.
 * @member {number} [resources.limits.memoryInGB] The memory limit in GB of
 * this container instance.
 * @member {number} [resources.limits.cpu] The CPU limit of this container
 * instance.
 * @member {object} [resources.limits.gpu] The GPU limit of this container
 * instance.
 * @member {number} [resources.limits.gpu.count] The count of the GPU resource.
 * @member {string} [resources.limits.gpu.sku] The SKU of the GPU resource.
 * Possible values include: 'K80', 'P100', 'V100'
 * @member {array} [volumeMounts] The volume mounts available to the container
 * instance.
 * @member {object} [livenessProbe] The liveness probe.
 * @member {object} [livenessProbe.exec] The execution command to probe
 * @member {array} [livenessProbe.exec.command] The commands to execute within
 * the container.
 * @member {object} [livenessProbe.httpGet] The Http Get settings to probe
 * @member {string} [livenessProbe.httpGet.path] The path to probe.
 * @member {number} [livenessProbe.httpGet.port] The port number to probe.
 * @member {string} [livenessProbe.httpGet.scheme] The scheme. Possible values
 * include: 'http', 'https'
 * @member {number} [livenessProbe.initialDelaySeconds] The initial delay
 * seconds.
 * @member {number} [livenessProbe.periodSeconds] The period seconds.
 * @member {number} [livenessProbe.failureThreshold] The failure threshold.
 * @member {number} [livenessProbe.successThreshold] The success threshold.
 * @member {number} [livenessProbe.timeoutSeconds] The timeout seconds.
 * @member {object} [readinessProbe] The readiness probe.
 * @member {object} [readinessProbe.exec] The execution command to probe
 * @member {array} [readinessProbe.exec.command] The commands to execute within
 * the container.
 * @member {object} [readinessProbe.httpGet] The Http Get settings to probe
 * @member {string} [readinessProbe.httpGet.path] The path to probe.
 * @member {number} [readinessProbe.httpGet.port] The port number to probe.
 * @member {string} [readinessProbe.httpGet.scheme] The scheme. Possible values
 * include: 'http', 'https'
 * @member {number} [readinessProbe.initialDelaySeconds] The initial delay
 * seconds.
 * @member {number} [readinessProbe.periodSeconds] The period seconds.
 * @member {number} [readinessProbe.failureThreshold] The failure threshold.
 * @member {number} [readinessProbe.successThreshold] The success threshold.
 * @member {number} [readinessProbe.timeoutSeconds] The timeout seconds.
 */
export interface Container {
  name: string;
  image: string;
  command?: string[];
  ports?: ContainerPort[];
  environmentVariables?: EnvironmentVariable[];
  readonly instanceView?: ContainerPropertiesInstanceView;
  resources: ResourceRequirements;
  volumeMounts?: VolumeMount[];
  livenessProbe?: ContainerProbe;
  readinessProbe?: ContainerProbe;
}

/**
 * @class
 * Initializes a new instance of the AzureFileVolume class.
 * @constructor
 * The properties of the Azure File volume. Azure File shares are mounted as
 * volumes.
 *
 * @member {string} shareName The name of the Azure File share to be mounted as
 * a volume.
 * @member {boolean} [readOnly] The flag indicating whether the Azure File
 * shared mounted as a volume is read-only.
 * @member {string} storageAccountName The name of the storage account that
 * contains the Azure File share.
 * @member {string} [storageAccountKey] The storage account access key used to
 * access the Azure File share.
 */
export interface AzureFileVolume {
  shareName: string;
  readOnly?: boolean;
  storageAccountName: string;
  storageAccountKey?: string;
}

/**
 * @class
 * Initializes a new instance of the GitRepoVolume class.
 * @constructor
 * Represents a volume that is populated with the contents of a git repository
 *
 * @member {string} [directory] Target directory name. Must not contain or
 * start with '..'.  If '.' is supplied, the volume directory will be the git
 * repository.  Otherwise, if specified, the volume will contain the git
 * repository in the subdirectory with the given name.
 * @member {string} repository Repository URL
 * @member {string} [revision] Commit hash for the specified revision.
 */
export interface GitRepoVolume {
  directory?: string;
  repository: string;
  revision?: string;
}

/**
 * @class
 * Initializes a new instance of the Volume class.
 * @constructor
 * The properties of the volume.
 *
 * @member {string} name The name of the volume.
 * @member {object} [azureFile] The Azure File volume.
 * @member {string} [azureFile.shareName] The name of the Azure File share to
 * be mounted as a volume.
 * @member {boolean} [azureFile.readOnly] The flag indicating whether the Azure
 * File shared mounted as a volume is read-only.
 * @member {string} [azureFile.storageAccountName] The name of the storage
 * account that contains the Azure File share.
 * @member {string} [azureFile.storageAccountKey] The storage account access
 * key used to access the Azure File share.
 * @member {object} [emptyDir] The empty directory volume.
 * @member {object} [secret] The secret volume.
 * @member {object} [gitRepo] The git repo volume.
 * @member {string} [gitRepo.directory] Target directory name. Must not contain
 * or start with '..'.  If '.' is supplied, the volume directory will be the
 * git repository.  Otherwise, if specified, the volume will contain the git
 * repository in the subdirectory with the given name.
 * @member {string} [gitRepo.repository] Repository URL
 * @member {string} [gitRepo.revision] Commit hash for the specified revision.
 */
export interface Volume {
  name: string;
  azureFile?: AzureFileVolume;
  emptyDir?: any;
  secret?: { [propertyName: string]: string };
  gitRepo?: GitRepoVolume;
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupIdentityUserAssignedIdentitiesValue class.
 * @constructor
 * @member {string} [principalId] The principal id of user assigned identity.
 * @member {string} [clientId] The client id of user assigned identity.
 */
export interface ContainerGroupIdentityUserAssignedIdentitiesValue {
  readonly principalId?: string;
  readonly clientId?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupIdentity class.
 * @constructor
 * Identity for the container group.
 *
 * @member {string} [principalId] The principal id of the container group
 * identity. This property will only be provided for a system assigned
 * identity.
 * @member {string} [tenantId] The tenant id associated with the container
 * group. This property will only be provided for a system assigned identity.
 * @member {string} [type] The type of identity used for the container group.
 * The type 'SystemAssigned, UserAssigned' includes both an implicitly created
 * identity and a set of user assigned identities. The type 'None' will remove
 * any identities from the container group. Possible values include:
 * 'SystemAssigned', 'UserAssigned', 'SystemAssigned, UserAssigned', 'None'
 * @member {object} [userAssignedIdentities] The list of user identities
 * associated with the container group. The user identity dictionary key
 * references will be ARM resource ids in the form:
 * '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
 */
export interface ContainerGroupIdentity {
  readonly principalId?: string;
  readonly tenantId?: string;
  type?: string;
  userAssignedIdentities?: { [propertyName: string]: ContainerGroupIdentityUserAssignedIdentitiesValue };
}

/**
 * @class
 * Initializes a new instance of the ImageRegistryCredential class.
 * @constructor
 * Image registry credential.
 *
 * @member {string} server The Docker image registry server without a protocol
 * such as "http" and "https".
 * @member {string} username The username for the private registry.
 * @member {string} [password] The password for the private registry.
 */
export interface ImageRegistryCredential {
  server: string;
  username: string;
  password?: string;
}

/**
 * @class
 * Initializes a new instance of the Port class.
 * @constructor
 * The port exposed on the container group.
 *
 * @member {string} [protocol] The protocol associated with the port. Possible
 * values include: 'TCP', 'UDP'
 * @member {number} port The port number.
 */
export interface Port {
  protocol?: string;
  port: number;
}

/**
 * @class
 * Initializes a new instance of the IpAddress class.
 * @constructor
 * IP address for the container group.
 *
 * @member {array} ports The list of ports exposed on the container group.
 * @member {string} type Specifies if the IP is exposed to the public internet
 * or private VNET. Possible values include: 'Public', 'Private'
 * @member {string} [ip] The IP exposed to the public internet.
 * @member {string} [dnsNameLabel] The Dns name label for the IP.
 * @member {string} [fqdn] The FQDN for the IP.
 */
export interface IpAddress {
  ports: Port[];
  type: string;
  ip?: string;
  dnsNameLabel?: string;
  readonly fqdn?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupPropertiesInstanceView class.
 * @constructor
 * The instance view of the container group. Only valid in response.
 *
 * @member {array} [events] The events of this container group.
 * @member {string} [state] The state of the container group. Only valid in
 * response.
 */
export interface ContainerGroupPropertiesInstanceView {
  readonly events?: Event[];
  readonly state?: string;
}

/**
 * @class
 * Initializes a new instance of the LogAnalytics class.
 * @constructor
 * Container group log analytics information.
 *
 * @member {string} workspaceId The workspace id for log analytics
 * @member {string} workspaceKey The workspace key for log analytics
 * @member {string} [logType] The log type to be used. Possible values include:
 * 'ContainerInsights', 'ContainerInstanceLogs'
 * @member {object} [metadata] Metadata for log analytics.
 */
export interface LogAnalytics {
  workspaceId: string;
  workspaceKey: string;
  logType?: string;
  metadata?: { [propertyName: string]: string };
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupDiagnostics class.
 * @constructor
 * Container group diagnostic information.
 *
 * @member {object} [logAnalytics] Container group log analytics information.
 * @member {string} [logAnalytics.workspaceId] The workspace id for log
 * analytics
 * @member {string} [logAnalytics.workspaceKey] The workspace key for log
 * analytics
 * @member {string} [logAnalytics.logType] The log type to be used. Possible
 * values include: 'ContainerInsights', 'ContainerInstanceLogs'
 * @member {object} [logAnalytics.metadata] Metadata for log analytics.
 */
export interface ContainerGroupDiagnostics {
  logAnalytics?: LogAnalytics;
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupNetworkProfile class.
 * @constructor
 * Container group network profile information.
 *
 * @member {string} id The identifier for a network profile.
 */
export interface ContainerGroupNetworkProfile {
  id: string;
}

/**
 * @class
 * Initializes a new instance of the DnsConfiguration class.
 * @constructor
 * DNS configuration for the container group.
 *
 * @member {array} nameServers The DNS servers for the container group.
 * @member {string} [searchDomains] The DNS search domains for hostname lookup
 * in the container group.
 * @member {string} [options] The DNS options for the container group.
 */
export interface DnsConfiguration {
  nameServers: string[];
  searchDomains?: string;
  options?: string;
}

/**
 * @class
 * Initializes a new instance of the Resource class.
 * @constructor
 * The Resource model definition.
 *
 * @member {string} [id] The resource id.
 * @member {string} [name] The resource name.
 * @member {string} [type] The resource type.
 * @member {string} [location] The resource location.
 * @member {object} [tags] The resource tags.
 */
export interface Resource extends BaseResource {
  readonly id?: string;
  readonly name?: string;
  readonly type?: string;
  location?: string;
  tags?: { [propertyName: string]: string };
}

/**
 * @class
 * Initializes a new instance of the ContainerGroup class.
 * @constructor
 * A container group.
 *
 * @member {object} [identity] The identity of the container group, if
 * configured.
 * @member {string} [identity.principalId] The principal id of the container
 * group identity. This property will only be provided for a system assigned
 * identity.
 * @member {string} [identity.tenantId] The tenant id associated with the
 * container group. This property will only be provided for a system assigned
 * identity.
 * @member {string} [identity.type] The type of identity used for the container
 * group. The type 'SystemAssigned, UserAssigned' includes both an implicitly
 * created identity and a set of user assigned identities. The type 'None' will
 * remove any identities from the container group. Possible values include:
 * 'SystemAssigned', 'UserAssigned', 'SystemAssigned, UserAssigned', 'None'
 * @member {object} [identity.userAssignedIdentities] The list of user
 * identities associated with the container group. The user identity dictionary
 * key references will be ARM resource ids in the form:
 * '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
 * @member {string} [provisioningState] The provisioning state of the container
 * group. This only appears in the response.
 * @member {array} containers The containers within the container group.
 * @member {array} [imageRegistryCredentials] The image registry credentials by
 * which the container group is created from.
 * @member {string} [restartPolicy] Restart policy for all containers within
 * the container group.
 * - `Always` Always restart
 * - `OnFailure` Restart on failure
 * - `Never` Never restart
 * . Possible values include: 'Always', 'OnFailure', 'Never'
 * @member {object} [ipAddress] The IP address type of the container group.
 * @member {array} [ipAddress.ports] The list of ports exposed on the container
 * group.
 * @member {string} [ipAddress.type] Specifies if the IP is exposed to the
 * public internet or private VNET. Possible values include: 'Public',
 * 'Private'
 * @member {string} [ipAddress.ip] The IP exposed to the public internet.
 * @member {string} [ipAddress.dnsNameLabel] The Dns name label for the IP.
 * @member {string} [ipAddress.fqdn] The FQDN for the IP.
 * @member {string} osType The operating system type required by the containers
 * in the container group. Possible values include: 'Windows', 'Linux'
 * @member {array} [volumes] The list of volumes that can be mounted by
 * containers in this container group.
 * @member {object} [instanceView] The instance view of the container group.
 * Only valid in response.
 * @member {array} [instanceView.events] The events of this container group.
 * @member {string} [instanceView.state] The state of the container group. Only
 * valid in response.
 * @member {object} [diagnostics] The diagnostic information for a container
 * group.
 * @member {object} [diagnostics.logAnalytics] Container group log analytics
 * information.
 * @member {string} [diagnostics.logAnalytics.workspaceId] The workspace id for
 * log analytics
 * @member {string} [diagnostics.logAnalytics.workspaceKey] The workspace key
 * for log analytics
 * @member {string} [diagnostics.logAnalytics.logType] The log type to be used.
 * Possible values include: 'ContainerInsights', 'ContainerInstanceLogs'
 * @member {object} [diagnostics.logAnalytics.metadata] Metadata for log
 * analytics.
 * @member {object} [networkProfile] The network profile information for a
 * container group.
 * @member {string} [networkProfile.id] The identifier for a network profile.
 * @member {object} [dnsConfig] The DNS config information for a container
 * group.
 * @member {array} [dnsConfig.nameServers] The DNS servers for the container
 * group.
 * @member {string} [dnsConfig.searchDomains] The DNS search domains for
 * hostname lookup in the container group.
 * @member {string} [dnsConfig.options] The DNS options for the container
 * group.
 */
export interface ContainerGroup extends Resource {
  identity?: ContainerGroupIdentity;
  readonly provisioningState?: string;
  containers: Container[];
  imageRegistryCredentials?: ImageRegistryCredential[];
  restartPolicy?: string;
  ipAddress?: IpAddress;
  osType: string;
  volumes?: Volume[];
  readonly instanceView?: ContainerGroupPropertiesInstanceView;
  diagnostics?: ContainerGroupDiagnostics;
  networkProfile?: ContainerGroupNetworkProfile;
  dnsConfig?: DnsConfiguration;
}

/**
 * @class
 * Initializes a new instance of the OperationDisplay class.
 * @constructor
 * The display information of the operation.
 *
 * @member {string} [provider] The name of the provider of the operation.
 * @member {string} [resource] The name of the resource type of the operation.
 * @member {string} [operation] The friendly name of the operation.
 * @member {string} [description] The description of the operation.
 */
export interface OperationDisplay {
  provider?: string;
  resource?: string;
  operation?: string;
  description?: string;
}

/**
 * @class
 * Initializes a new instance of the Operation class.
 * @constructor
 * An operation for Azure Container Instance service.
 *
 * @member {string} name The name of the operation.
 * @member {object} display The display information of the operation.
 * @member {string} [display.provider] The name of the provider of the
 * operation.
 * @member {string} [display.resource] The name of the resource type of the
 * operation.
 * @member {string} [display.operation] The friendly name of the operation.
 * @member {string} [display.description] The description of the operation.
 * @member {string} [origin] The intended executor of the operation. Possible
 * values include: 'User', 'System'
 */
export interface Operation {
  name: string;
  display: OperationDisplay;
  origin?: string;
}

/**
 * @class
 * Initializes a new instance of the OperationListResult class.
 * @constructor
 * The operation list response that contains all operations for Azure Container
 * Instance service.
 *
 * @member {array} [value] The list of operations.
 * @member {string} [nextLink] The URI to fetch the next page of operations.
 */
export interface OperationListResult {
  value?: Operation[];
  nextLink?: string;
}

/**
 * @class
 * Initializes a new instance of the UsageName class.
 * @constructor
 * The name object of the resource
 *
 * @member {string} [value] The name of the resource
 * @member {string} [localizedValue] The localized name of the resource
 */
export interface UsageName {
  readonly value?: string;
  readonly localizedValue?: string;
}

/**
 * @class
 * Initializes a new instance of the Usage class.
 * @constructor
 * A single usage result
 *
 * @member {string} [unit] Unit of the usage result
 * @member {number} [currentValue] The current usage of the resource
 * @member {number} [limit] The maximum permitted usage of the resource.
 * @member {object} [name] The name object of the resource
 * @member {string} [name.value] The name of the resource
 * @member {string} [name.localizedValue] The localized name of the resource
 */
export interface Usage {
  readonly unit?: string;
  readonly currentValue?: number;
  readonly limit?: number;
  readonly name?: UsageName;
}

/**
 * @class
 * Initializes a new instance of the UsageListResult class.
 * @constructor
 * The response containing the usage data
 *
 * @member {array} [value]
 */
export interface UsageListResult {
  readonly value?: Usage[];
}

/**
 * @class
 * Initializes a new instance of the Logs class.
 * @constructor
 * The logs.
 *
 * @member {string} [content] The content of the log.
 */
export interface Logs {
  content?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerExecRequestTerminalSize class.
 * @constructor
 * The size of the terminal.
 *
 * @member {number} [rows] The row size of the terminal
 * @member {number} [cols] The column size of the terminal
 */
export interface ContainerExecRequestTerminalSize {
  rows?: number;
  cols?: number;
}

/**
 * @class
 * Initializes a new instance of the ContainerExecRequest class.
 * @constructor
 * The container exec request.
 *
 * @member {string} [command] The command to be executed.
 * @member {object} [terminalSize] The size of the terminal.
 * @member {number} [terminalSize.rows] The row size of the terminal
 * @member {number} [terminalSize.cols] The column size of the terminal
 */
export interface ContainerExecRequest {
  command?: string;
  terminalSize?: ContainerExecRequestTerminalSize;
}

/**
 * @class
 * Initializes a new instance of the ContainerExecResponse class.
 * @constructor
 * The information for the container exec command.
 *
 * @member {string} [webSocketUri] The uri for the exec websocket.
 * @member {string} [password] The password to start the exec command.
 */
export interface ContainerExecResponse {
  webSocketUri?: string;
  password?: string;
}

/**
 * @class
 * Initializes a new instance of the ContainerGroupListResult class.
 * @constructor
 * The container group list response that contains the container group
 * properties.
 *
 * @member {string} [nextLink] The URI to fetch the next page of container
 * groups.
 */
export interface ContainerGroupListResult extends Array<ContainerGroup> {
  nextLink?: string;
}

redpajama_set_name: RedPajamaGithub


text:
package parser

import (
	"fmt"
	"go/ast"
	. "github.com/t-yuki/godoc2puml/ast"
)

type methodVisitor struct {
	astPackage *ast.Package
	astFile    *ast.File
	pkg        *Package
	name2class map[string]*Class
}

func (v *methodVisitor) Visit(node ast.Node) ast.Visitor {
	switch node := node.(type) {
	case *ast.Package:
		v.astPackage = node
		return v
	case *ast.File:
		v.astFile = node
		return v
	case *ast.FuncDecl:
		v.visitFuncDecl(node)
	default:
		return v
	}
	return nil
}

func (v *methodVisitor) visitFuncDecl(node *ast.FuncDecl) {
	if node.Recv == nil {
		return
	}
	recv := node.Recv.List[0]
	typeName := elementType(recv.Type)
	class, ok := v.name2class[typeName]
	if !ok {
		// unknown method receiver
		return
	}
	method := &Method{
		Name:      node.Name.String(),
		Arguments: make([]DeclPair, 0, 10),
		Results:   make([]DeclPair, 0, 10),
	}
	method.Public = ast.IsExported(method.Name)
	parseFuncType(method, node.Type)
	class.Methods = append(class.Methods, method)
}

func elementType(expr ast.Expr) string {
	if expr == nil {
		return ""
	}
	switch expr := expr.(type) {
	case *ast.Ident:
		return expr.String()
	case *ast.ArrayType:
		return elementType(expr.Elt)
	case *ast.StarExpr:
		return elementType(expr.X)
	default:
		panic(fmt.Errorf("%#v", expr))
	}
}

func parseFuncType(method *Method, node *ast.FuncType) {
	for _, field := range node.Params.List {
		argType := typeGoString(field.Type)
		if len(field.Names) == 0 {
			method.Arguments = append(method.Arguments, DeclPair{"", argType})
		}
		for _, name := range field.Names {
			method.Arguments = append(method.Arguments, DeclPair{name.String(), argType})
		}
	}
	if node.Results != nil {
		for _, field := range node.Results.List {
			argType := typeGoString(field.Type)
			if len(field.Names) == 0 {
				method.Results = append(method.Results, DeclPair{"", argType})
			}
			for _, name := range field.Names {
				method.Results = append(method.Results, DeclPair{name.String(), argType})
			}
		}
	}
}


text:
__title__ = 'splash'
__version__ = '0.0.1'

from .splash import SplashVersion1
from .spectrum import Spectrum
from .spectrum_type import SpectrumType


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Microsoft.Azure.Documents.Client;
using Microsoft.Azure.Documents;
using System.Threading.Tasks;
using System.Linq.Expressions;

namespace RFIDModuleScan.Droid.DocumentDb
{
    /// <summary>
    /// This class is a singleton static class adapted from the Azure Cosmos DB starter samples
    /// It is used to hold a single client session open for the application to share.  This
    /// enables session consistency so a single client will always see it's own updates.
    /// </summary>
    public static class DocumentDBContext
    {
        public static string DatabaseId = "CottonModuleDB";
        public static string CollectionId = "CottonDocs";

        private static DocumentClient client;

        public static bool Initialized
        {
            get
            {
                return client != null;
            }
        }

        /*public static async Task<T> GetItemAsync<T>(string id)
        {
            try
            {
                Document document = await client.ReadDocumentAsync(UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id));
                return (T)(dynamic)document;
            }
            catch (DocumentClientException e)
            {
                if (e.StatusCode == System.Net.HttpStatusCode.NotFound)
                {
                    return default(T);
                }
                else
                {
                    throw;
                }
            }
        }*/

        public static IEnumerable<T> GetAllItems<T>(Expression<Func<T, bool>> predicate) where T : class
        {
            IQueryable<T> query = client.CreateDocumentQuery<T>(
               UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId))
               .Where(predicate);

            return query.ToList();
        }

        public static IEnumerable<T> GetAllItems<T>() where T : class
        {
            IQueryable<T> query = client.CreateDocumentQuery<T>(
               UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId));

            return query.ToList();
        }

        public static void Initialize(string endpoint, string authKey)
        {
            var policy = new ConnectionPolicy
            {
                ConnectionMode = ConnectionMode.Direct,
                ConnectionProtocol = Protocol.Https,
                EnableEndpointDiscovery = false
            };

            client = new DocumentClient(new Uri(endpoint), authKey,
                policy, ConsistencyLevel.Eventual);
        }
    }
}


text:
package com.bagri.xdm.access.coherence.process;

import java.io.IOException;

import com.tangosol.io.pof.PofReader;
import com.tangosol.io.pof.PofWriter;
import com.tangosol.io.pof.PortableObject;
import com.tangosol.util.InvocableMap.Entry;
import com.tangosol.util.processor.AbstractProcessor;

public class DocumentCreator extends AbstractProcessor implements PortableObject {

	protected String uri;
	protected String xml;

	public DocumentCreator() {
	}

	public DocumentCreator(String uri, String xml) {
		this();
		this.uri = uri;
		this.xml = xml;
	}

	@Override
	public Object process(Entry entry) {

		//XDMDocumentManagerServer xdm = ((SpringAwareCacheFactory) CacheFactory.getConfigurableCacheFactory()).getSpringBean("xdmManager", XDMDocumentManagerServer.class);
		//if (xdm == null) {
		//	throw new IllegalStateException("XDM Server Context is not ready");
		//}
		return null; //xdm.createDocument(entry, uri, xml);
	}

	@Override
	public void readExternal(PofReader in) throws IOException {
		uri = in.readString(0);
		xml = in.readString(1);
	}

	@Override
	public void writeExternal(PofWriter out) throws IOException {
		out.writeString(0, uri);
		out.writeString(1, xml);
	}

}


text:
require 'rainbow'
require 'rainbow/ext/string'
require 'scss_lint/options'

module SCSSLint
  # Responsible for parsing command-line options and executing the appropriate
  # application logic based on the options specified.
  class CLI
    attr_reader :config, :options

    # Subset of semantic exit codes conforming to `sysexits` documentation.
    EXIT_CODES = {
      ok:             0,
      warning:        1,  # One or more warnings (but no errors) were reported
      error:          2,  # One or more errors were reported
      usage:          64, # Command line usage error
      no_input:       66, # Input file did not exist or was not readable
      unavailable:    69, # Required library is unavailable
      software:       70, # Internal software error
      config:         78, # Configuration error
      no_files:       80, # No files matched by specified glob patterns
      plugin:         82, # Plugin loading error
    }

    def run(args)
      options = SCSSLint::Options.new.parse(args)
      act_on_options(options)
    rescue => ex
      handle_runtime_exception(ex, options)
    end

  private

    def act_on_options(options)
      load_required_paths(options)
      load_reporters(options)

      if options[:help]
        print_help(options)
      elsif options[:version]
        print_version
      elsif options[:show_formatters]
        print_formatters
      else
        config = setup_configuration(options)

        if options[:show_linters]
          print_linters
        else
          scan_for_lints(options, config)
        end
      end
    end

    def scan_for_lints(options, config)
      runner = Runner.new(config)
      runner.run(FileFinder.new(config).find(options[:files]))
      report_lints(options, runner.lints, runner.files)

      if runner.lints.any?(&:error?)
        halt :error
      elsif runner.lints.any?
        halt :warning
      else
        halt :ok
      end
    end

    def handle_runtime_exception(exception, options) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/LineLength, Metrics/MethodLength
      case exception
      when SCSSLint::Exceptions::InvalidCLIOption
        puts exception.message
        puts 'Run `scss-lint --help` for usage documentation'
        halt :usage
      when SCSSLint::Exceptions::InvalidConfiguration
        puts exception.message
        halt :config
      when SCSSLint::Exceptions::RequiredLibraryMissingError
        puts exception.message
        halt :unavailable
      when SCSSLint::Exceptions::NoFilesError
        puts exception.message
        halt :no_files
      when SCSSLint::Exceptions::PluginGemLoadError
        puts exception.message
        halt :plugin
      when Errno::ENOENT
        puts exception.message
        halt :no_input
      when NoSuchLinter
        puts exception.message
        halt :usage
      else
        config_file = relevant_configuration_file(options) if options

        puts exception.message
        puts exception.backtrace
        puts 'Report this bug at '.color(:yellow) + BUG_REPORT_URL.color(:cyan)
        puts
        puts 'To help fix this issue, please include:'.color(:green)
        puts '- The above stack trace'
        puts "- SCSS-Lint version: #{SCSSLint::VERSION.color(:cyan)}"
        puts "- Sass version: #{Gem.loaded_specs['sass'].version.to_s.color(:cyan)}"
        puts "- Ruby version: #{RUBY_VERSION.color(:cyan)}"
        puts "- Contents of #{File.expand_path(config_file).color(:cyan)}" if config_file
        halt :software
      end
    end

    def setup_configuration(options)
      config_file = relevant_configuration_file(options)
      config = config_file ? Config.load(config_file) : Config.default
      merge_options_with_config(options, config)
    end

    # Return the path of the configuration file that should be loaded.
    #
    # @param options [Hash]
    # @return [String]
    def relevant_configuration_file(options)
      if options[:config_file]
        options[:config_file]
      elsif File.exist?(Config::FILE_NAME)
        Config::FILE_NAME
      elsif File.exist?(Config.user_file)
        Config.user_file
      end
    end

    # @param options [Hash]
    # @param config [Config]
    # @return [Config]
    def merge_options_with_config(options, config)
      if options[:excluded_files]
        options[:excluded_files].each do |file|
          config.exclude_file(file)
        end
      end

      if options[:included_linters]
        config.disable_all_linters
        LinterRegistry.extract_linters_from(options[:included_linters]).each do |linter|
          config.enable_linter(linter)
        end
      end

      if options[:excluded_linters]
        LinterRegistry.extract_linters_from(options[:excluded_linters]).each do |linter|
          config.disable_linter(linter)
        end
      end

      config
    end

    # @param options [Hash]
    # @param lints [Array<Lint>]
    # @param files [Array<String>]
    def report_lints(options, lints, files)
      sorted_lints = lints.sort_by { |l| [l.filename, l.location] }
      options.fetch(:reporters).each do |reporter, output|
        results = reporter.new(sorted_lints, files).report_lints
        io = (output == :stdout ? $stdout : File.new(output, 'w+'))
        io.print results if results
      end
    end

    def load_required_paths(options)
      Array(options[:required_paths]).each do |path|
        require path
      end
    rescue LoadError => ex
      raise SCSSLint::Exceptions::RequiredLibraryMissingError,
            "Required library not found: #{ex.message}"
    end

    def load_reporters(options)
      options[:reporters].map! do |reporter_name, output_file|
        begin
          reporter = SCSSLint::Reporter.const_get(reporter_name + 'Reporter')
        rescue NameError
          raise SCSSLint::Exceptions::InvalidCLIOption,
                "Invalid output format specified: #{reporter_name}"
        end
        [reporter, output_file]
      end
    end

    def print_formatters
      puts 'Installed formatters:'

      reporter_names = SCSSLint::Reporter.descendants.map do |reporter|
        reporter.name.split('::').last.split('Reporter').first
      end

      reporter_names.sort.each do |reporter_name|
        puts " - #{reporter_name}"
      end

      halt
    end

    def print_linters
      puts 'Installed linters:'

      linter_names = LinterRegistry.linters.map do |linter|
        linter.name.split('::').last
      end

      linter_names.sort.each do |linter_name|
        puts " - #{linter_name}"
      end

      halt
    end

    # @param options [Hash]
    def print_help(options)
      puts options[:help]
      halt :ok
    end

    # @param options [Hash]
    def print_version
      puts "scss-lint #{SCSSLint::VERSION}"
      halt :ok
    end

    # Used for ease-of testing
    # @param exit_status [Symbol]
    def halt(exit_status = :ok)
      EXIT_CODES[exit_status]
    end
  end
end


text:
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef SOCKET_FACTORY_H
#define SOCKET_FACTORY_H

#include "ns3/object.h"
#include "ns3/ptr.h"

namespace ns3 {

class Socket;

/**
 * \ingroup socket
 *
 * \brief Object to create transport layer instances that provide a
 * socket API to applications.
 *
 * This base class defines the API for creating sockets.
 * The socket factory also can hold the global variables used to
 * initialize newly created sockets, such as values that are
 * set through the sysctl or proc interfaces in Linux.

 * If you want to write a new transport protocol accessible through
 * sockets, you need to subclass this factory class, implement CreateSocket,
 * instantiate the object, and aggregate it to the node.
 *
 * \see Udp
 * \see UdpImpl
 */
class SocketFactory : public Object
{
public:
  static TypeId GetTypeId (void);

  SocketFactory ();

  /**
   * \return smart pointer to Socket
   *
   * Base class method for creating socket instances.
   */
  virtual Ptr<Socket> CreateSocket (void) = 0;
};

} // namespace ns3

#endif /* SOCKET_FACTORY_H */


text:
/*-
 *  modified for Lites 1.1
 *
 *  Aug 1995, Godmar Back (gback@cs.utah.edu)
 *  University of Utah, Department of Computer Science
 */
/*-
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * 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.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 *	@(#)ufs_lookup.c	8.6 (Berkeley) 4/1/94
 * $FreeBSD: soc2013/dpl/head/sys/fs/ext2fs/ext2_lookup.c 252875 2013-06-12 15:24:48Z pfg $
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/endian.h>
#include <sys/mount.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <sys/dirent.h>
#include <sys/sysctl.h>

#include <ufs/ufs/dir.h>

#include <fs/ext2fs/inode.h>
#include <fs/ext2fs/ext2_mount.h>
#include <fs/ext2fs/ext2fs.h>
#include <fs/ext2fs/ext2_dinode.h>
#include <fs/ext2fs/ext2_dir.h>
#include <fs/ext2fs/ext2_extern.h>

#ifdef INVARIANTS
static int dirchk = 1;
#else
static int dirchk = 0;
#endif

static SYSCTL_NODE(_vfs, OID_AUTO, e2fs, CTLFLAG_RD, 0, "EXT2FS filesystem");
SYSCTL_INT(_vfs_e2fs, OID_AUTO, dircheck, CTLFLAG_RW, &dirchk, 0, "");

/*
   DIRBLKSIZE in ffs is DEV_BSIZE (in most cases 512)
   while it is the native blocksize in ext2fs - thus, a #define
   is no longer appropriate
*/
#undef  DIRBLKSIZ

static u_char ext2_ft_to_dt[] = {
	DT_UNKNOWN,		/* EXT2_FT_UNKNOWN */
	DT_REG,			/* EXT2_FT_REG_FILE */
	DT_DIR,			/* EXT2_FT_DIR */
	DT_CHR,			/* EXT2_FT_CHRDEV */
	DT_BLK,			/* EXT2_FT_BLKDEV */
	DT_FIFO,		/* EXT2_FT_FIFO */
	DT_SOCK,		/* EXT2_FT_SOCK */
	DT_LNK,			/* EXT2_FT_SYMLINK */
};
#define	FTTODT(ft) \
    ((ft) < nitems(ext2_ft_to_dt) ? ext2_ft_to_dt[(ft)] : DT_UNKNOWN)

static u_char dt_to_ext2_ft[] = {
	EXT2_FT_UNKNOWN,	/* DT_UNKNOWN */
	EXT2_FT_FIFO,		/* DT_FIFO */
	EXT2_FT_CHRDEV,		/* DT_CHR */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_DIR,		/* DT_DIR */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_BLKDEV,		/* DT_BLK */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_REG_FILE,	/* DT_REG */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_SYMLINK,	/* DT_LNK */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_SOCK,		/* DT_SOCK */
	EXT2_FT_UNKNOWN,	/* unused */
	EXT2_FT_UNKNOWN,	/* DT_WHT */
};
#define	DTTOFT(dt) \
    ((dt) < nitems(dt_to_ext2_ft) ? dt_to_ext2_ft[(dt)] : EXT2_FT_UNKNOWN)

static int	ext2_dirbadentry(struct vnode *dp, struct ext2fs_direct_2 *de,
		    int entryoffsetinblock);
static int	ext2_lookup_ino(struct vnode *vdp, struct vnode **vpp,
		    struct componentname *cnp, ino_t *dd_ino);

/*
 * Vnode op for reading directories.
 *
 * This function has to convert directory entries from the on-disk
 * format to the format defined by <sys/dirent.h>.  Unfortunately, the
 * conversion will blow up some entries by four bytes, so it can't be
 * done in place.  Instead, the conversion is done entry by entry and
 * the converted entry is sent via uiomove.
 *
 * XXX allocate a buffer, convert as many entries as possible, then send
 * the whole buffer to uiomove
 */
int
ext2_readdir(struct vop_readdir_args *ap)
{
	struct uio *uio = ap->a_uio;
	int count, error;

	struct ext2fs_direct_2 *edp, *dp;
	int ncookies;
	struct dirent dstdp;
	struct uio auio;
	struct iovec aiov;
	caddr_t dirbuf;
	int DIRBLKSIZ = VTOI(ap->a_vp)->i_e2fs->e2fs_bsize;
	int readcnt;
	off_t startoffset = uio->uio_offset;

	count = uio->uio_resid;
	/*
	 * Avoid complications for partial directory entries by adjusting
	 * the i/o to end at a block boundary.  Don't give up (like ufs
	 * does) if the initial adjustment gives a negative count, since
	 * many callers don't supply a large enough buffer.  The correct
	 * size is a little larger than DIRBLKSIZ to allow for expansion
	 * of directory entries, but some callers just use 512.
	 */
	count -= (uio->uio_offset + count) & (DIRBLKSIZ -1);
	if (count <= 0)
		count += DIRBLKSIZ;
	auio = *uio;
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	auio.uio_resid = count;
	auio.uio_segflg = UIO_SYSSPACE;
	aiov.iov_len = count;
	dirbuf = malloc(count, M_TEMP, M_WAITOK);
	aiov.iov_base = dirbuf;
	error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred);
	if (error == 0) {
		readcnt = count - auio.uio_resid;
		edp = (struct ext2fs_direct_2 *)&dirbuf[readcnt];
		ncookies = 0;
		bzero(&dstdp, offsetof(struct dirent, d_name));
		for (dp = (struct ext2fs_direct_2 *)dirbuf;
		    !error && uio->uio_resid > 0 && dp < edp; ) {
			/*-
			 * "New" ext2fs directory entries differ in 3 ways
			 * from ufs on-disk ones:
			 * - the name is not necessarily NUL-terminated.
			 * - the file type field always exists and always
			 *   follows the name length field.
			 * - the file type is encoded in a different way.
			 *
			 * "Old" ext2fs directory entries need no special
			 * conversions, since they are binary compatible
			 * with "new" entries having a file type of 0 (i.e.,
			 * EXT2_FT_UNKNOWN).  Splitting the old name length
			 * field didn't make a mess like it did in ufs,
			 * because ext2fs uses a machine-independent disk
			 * layout.
			 */
			dstdp.d_fileno = dp->e2d_ino;
			dstdp.d_type = FTTODT(dp->e2d_type);
			dstdp.d_namlen = dp->e2d_namlen;
			dstdp.d_reclen = GENERIC_DIRSIZ(&dstdp);
			bcopy(dp->e2d_name, dstdp.d_name, dstdp.d_namlen);
			bzero(dstdp.d_name + dstdp.d_namlen,
			    dstdp.d_reclen - offsetof(struct dirent, d_name) -
			    dstdp.d_namlen);

			if (dp->e2d_reclen > 0) {
				if(dstdp.d_reclen <= uio->uio_resid) {
					/* advance dp */
					dp = (struct ext2fs_direct_2 *)
					    ((char *)dp + dp->e2d_reclen);
					error =
					  uiomove(&dstdp, dstdp.d_reclen, uio);
					if (!error)
						ncookies++;
				} else
					break;
			} else {
				error = EIO;
				break;
			}
		}
		/* we need to correct uio_offset */
		uio->uio_offset = startoffset + (caddr_t)dp - dirbuf;

		if (!error && ap->a_ncookies != NULL) {
			u_long *cookiep, *cookies, *ecookies;
			off_t off;

			if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
				panic("ext2_readdir: unexpected uio from NFS server");
			cookies = malloc(ncookies * sizeof(u_long), M_TEMP,
			       M_WAITOK);
			off = startoffset;
			for (dp = (struct ext2fs_direct_2 *)dirbuf,
			     cookiep = cookies, ecookies = cookies + ncookies;
			     cookiep < ecookies;
			     dp = (struct ext2fs_direct_2 *)((caddr_t) dp + dp->e2d_reclen)) {
				off += dp->e2d_reclen;
				*cookiep++ = (u_long) off;
			}
			*ap->a_ncookies = ncookies;
			*ap->a_cookies = cookies;
		}
	}
	free(dirbuf, M_TEMP);
	if (ap->a_eofflag)
		*ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset;
	return (error);
}

/*
 * Convert a component of a pathname into a pointer to a locked inode.
 * This is a very central and rather complicated routine.
 * If the file system is not maintained in a strict tree hierarchy,
 * this can result in a deadlock situation (see comments in code below).
 *
 * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
 * on whether the name is to be looked up, created, renamed, or deleted.
 * When CREATE, RENAME, or DELETE is specified, information usable in
 * creating, renaming, or deleting a directory entry may be calculated.
 * If flag has LOCKPARENT or'ed into it and the target of the pathname
 * exists, lookup returns both the target and its parent directory locked.
 * When creating or renaming and LOCKPARENT is specified, the target may
 * not be ".".  When deleting and LOCKPARENT is specified, the target may
 * be "."., but the caller must check to ensure it does an vrele and vput
 * instead of two vputs.
 *
 * Overall outline of ext2_lookup:
 *
 *	search for name in directory, to found or notfound
 * notfound:
 *	if creating, return locked directory, leaving info on available slots
 *	else return error
 * found:
 *	if at end of path and deleting, return information to allow delete
 *	if at end of path and rewriting (RENAME and LOCKPARENT), lock target
 *	  inode and return info to allow rewrite
 *	if not at end, add name to cache; if at end and neither creating
 *	  nor deleting, add name to cache
 */
int
ext2_lookup(struct vop_cachedlookup_args *ap)
{

	return (ext2_lookup_ino(ap->a_dvp, ap->a_vpp, ap->a_cnp, NULL));
}

static int
ext2_lookup_ino(struct vnode *vdp, struct vnode **vpp, struct componentname *cnp,
    ino_t *dd_ino)
{
	struct inode *dp;		/* inode for directory being searched */
	struct buf *bp;			/* a buffer of directory entries */
	struct ext2fs_direct_2 *ep;	/* the current directory entry */
	int entryoffsetinblock;		/* offset of ep in bp's buffer */
	enum {NONE, COMPACT, FOUND} slotstatus;
	doff_t slotoffset;		/* offset of area with free space */
	int slotsize;			/* size of area at slotoffset */
	doff_t i_diroff;		/* cached i_diroff value */
	doff_t i_offset;		/* cached i_offset value */
	int slotfreespace;		/* amount of space free in slot */
	int slotneeded;			/* size of the entry we're seeking */
	int numdirpasses;		/* strategy for directory search */
	doff_t endsearch;		/* offset to end directory search */
	doff_t prevoff;			/* prev entry dp->i_offset */
	struct vnode *pdp;		/* saved dp during symlink work */
	struct vnode *tdp;		/* returned by VFS_VGET */
	doff_t enduseful;		/* pointer past last used dir slot */
	u_long bmask;			/* block offset mask */
	int namlen, error;
	struct ucred *cred = cnp->cn_cred;
	int flags = cnp->cn_flags;
	int nameiop = cnp->cn_nameiop;
	ino_t ino, ino1;
	int ltype;

	int	DIRBLKSIZ = VTOI(vdp)->i_e2fs->e2fs_bsize;

	if (vpp != NULL)
		*vpp = NULL;

	dp = VTOI(vdp);
	bmask = VFSTOEXT2(vdp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
restart:
	bp = NULL;
	slotoffset = -1;

	/*
	 * We now have a segment name to search for, and a directory to search.
	 */

	/*
	 * Suppress search for slots unless creating
	 * file and at end of pathname, in which case
	 * we watch for a place to put the new file in
	 * case it doesn't already exist.
	 */
	ino = 0;
	i_diroff = dp->i_diroff;
	slotstatus = FOUND;
	slotfreespace = slotsize = slotneeded = 0;
	if ((nameiop == CREATE || nameiop == RENAME) &&
	    (flags & ISLASTCN)) {
		slotstatus = NONE;
		slotneeded = EXT2_DIR_REC_LEN(cnp->cn_namelen);
		/* was
		slotneeded = (sizeof(struct direct) - MAXNAMLEN +
			cnp->cn_namelen + 3) &~ 3; */
	}

	/*
	 * If there is cached information on a previous search of
	 * this directory, pick up where we last left off.
	 * We cache only lookups as these are the most common
	 * and have the greatest payoff. Caching CREATE has little
	 * benefit as it usually must search the entire directory
	 * to determine that the entry does not exist. Caching the
	 * location of the last DELETE or RENAME has not reduced
	 * profiling time and hence has been removed in the interest
	 * of simplicity.
	 */
	if (nameiop != LOOKUP || i_diroff == 0 ||
	    i_diroff > dp->i_size) {
		entryoffsetinblock = 0;
		i_offset = 0;
		numdirpasses = 1;
	} else {
		i_offset = i_diroff;
		if ((entryoffsetinblock = i_offset & bmask) &&
		    (error = ext2_blkatoff(vdp, (off_t)i_offset, NULL,
		    &bp)))
			return (error);
		numdirpasses = 2;
		nchstats.ncs_2passes++;
	}
	prevoff = i_offset;
	endsearch = roundup2(dp->i_size, DIRBLKSIZ);
	enduseful = 0;

searchloop:
	while (i_offset < endsearch) {
		/*
		 * If necessary, get the next directory block.
		 */
		if ((i_offset & bmask) == 0) {
			if (bp != NULL)
				brelse(bp);
			if ((error =
			    ext2_blkatoff(vdp, (off_t)i_offset, NULL,
			    &bp)) != 0)
				return (error);
			entryoffsetinblock = 0;
		}
		/*
		 * If still looking for a slot, and at a DIRBLKSIZE
		 * boundary, have to start looking for free space again.
		 */
		if (slotstatus == NONE &&
		    (entryoffsetinblock & (DIRBLKSIZ - 1)) == 0) {
			slotoffset = -1;
			slotfreespace = 0;
		}
		/*
		 * Get pointer to next entry.
		 * Full validation checks are slow, so we only check
		 * enough to insure forward progress through the
		 * directory. Complete checks can be run by setting
		 * "vfs.e2fs.dirchk" to be true.
		 */
		ep = (struct ext2fs_direct_2 *)
			((char *)bp->b_data + entryoffsetinblock);
		if (ep->e2d_reclen == 0 ||
		    (dirchk && ext2_dirbadentry(vdp, ep, entryoffsetinblock))) {
			int i;
			ext2_dirbad(dp, i_offset, "mangled entry");
			i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
			i_offset += i;
			entryoffsetinblock += i;
			continue;
		}

		/*
		 * If an appropriate sized slot has not yet been found,
		 * check to see if one is available. Also accumulate space
		 * in the current block so that we can determine if
		 * compaction is viable.
		 */
		if (slotstatus != FOUND) {
			int size = ep->e2d_reclen;

			if (ep->e2d_ino != 0)
				size -= EXT2_DIR_REC_LEN(ep->e2d_namlen);
			if (size > 0) {
				if (size >= slotneeded) {
					slotstatus = FOUND;
					slotoffset = i_offset;
					slotsize = ep->e2d_reclen;
				} else if (slotstatus == NONE) {
					slotfreespace += size;
					if (slotoffset == -1)
						slotoffset = i_offset;
					if (slotfreespace >= slotneeded) {
						slotstatus = COMPACT;
						slotsize = i_offset +
						      ep->e2d_reclen - slotoffset;
					}
				}
			}
		}

		/*
		 * Check for a name match.
		 */
		if (ep->e2d_ino) {
			namlen = ep->e2d_namlen;
			if (namlen == cnp->cn_namelen &&
			    !bcmp(cnp->cn_nameptr, ep->e2d_name,
				(unsigned)namlen)) {
				/*
				 * Save directory entry's inode number and
				 * reclen in ndp->ni_ufs area, and release
				 * directory buffer.
				 */
				ino = ep->e2d_ino;
				goto found;
			}
		}
		prevoff = i_offset;
		i_offset += ep->e2d_reclen;
		entryoffsetinblock += ep->e2d_reclen;
		if (ep->e2d_ino)
			enduseful = i_offset;
	}
/* notfound: */
	/*
	 * If we started in the middle of the directory and failed
	 * to find our target, we must check the beginning as well.
	 */
	if (numdirpasses == 2) {
		numdirpasses--;
		i_offset = 0;
		endsearch = i_diroff;
		goto searchloop;
	}
	dp->i_offset = i_offset;
	if (bp != NULL)
		brelse(bp);
	/*
	 * If creating, and at end of pathname and current
	 * directory has not been removed, then can consider
	 * allowing file to be created.
	 */
	if ((nameiop == CREATE || nameiop == RENAME) &&
	    (flags & ISLASTCN) && dp->i_nlink != 0) {
		/*
		 * Access for write is interpreted as allowing
		 * creation of files in the directory.
		 */
		if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0)
			return (error);
		/*
		 * Return an indication of where the new directory
		 * entry should be put.  If we didn't find a slot,
		 * then set dp->i_count to 0 indicating
		 * that the new slot belongs at the end of the
		 * directory. If we found a slot, then the new entry
		 * can be put in the range from dp->i_offset to
		 * dp->i_offset + dp->i_count.
		 */
		if (slotstatus == NONE) {
			dp->i_offset = roundup2(dp->i_size, DIRBLKSIZ);
			dp->i_count = 0;
			enduseful = dp->i_offset;
		} else {
			dp->i_offset = slotoffset;
			dp->i_count = slotsize;
			if (enduseful < slotoffset + slotsize)
				enduseful = slotoffset + slotsize;
		}
		dp->i_endoff = roundup2(enduseful, DIRBLKSIZ);
		dp->i_flag |= IN_CHANGE | IN_UPDATE;
		/*
		 * We return with the directory locked, so that
		 * the parameters we set up above will still be
		 * valid if we actually decide to do a direnter().
		 * We return ni_vp == NULL to indicate that the entry
		 * does not currently exist; we leave a pointer to
		 * the (locked) directory inode in ndp->ni_dvp.
		 * The pathname buffer is saved so that the name
		 * can be obtained later.
		 *
		 * NB - if the directory is unlocked, then this
		 * information cannot be used.
		 */
		cnp->cn_flags |= SAVENAME;
		return (EJUSTRETURN);
	}
	/*
	 * Insert name into cache (as non-existent) if appropriate.
	 */
	if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
		cache_enter(vdp, NULL, cnp);
	return (ENOENT);

found:
	if (dd_ino != NULL)
		*dd_ino = ino;
	if (numdirpasses == 2)
		nchstats.ncs_pass2++;
	/*
	 * Check that directory length properly reflects presence
	 * of this entry.
	 */
	if (entryoffsetinblock + EXT2_DIR_REC_LEN(ep->e2d_namlen)
		> dp->i_size) {
		ext2_dirbad(dp, i_offset, "i_size too small");
		dp->i_size = entryoffsetinblock+EXT2_DIR_REC_LEN(ep->e2d_namlen);
		dp->i_flag |= IN_CHANGE | IN_UPDATE;
	}
	brelse(bp);

	/*
	 * Found component in pathname.
	 * If the final component of path name, save information
	 * in the cache as to where the entry was found.
	 */
	if ((flags & ISLASTCN) && nameiop == LOOKUP)
		dp->i_diroff = i_offset &~ (DIRBLKSIZ - 1);
	dp->i_offset = i_offset;
	/*
	 * If deleting, and at end of pathname, return
	 * parameters which can be used to remove file.
	 */
	if (nameiop == DELETE && (flags & ISLASTCN)) {
		/*
		 * Write access to directory required to delete files.
		 */
		if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0)
			return (error);
		/*
		 * Return pointer to current entry in dp->i_offset,
		 * and distance past previous entry (if there
		 * is a previous entry in this block) in dp->i_count.
		 * Save directory inode pointer in ndp->ni_dvp for dirremove().
		 */
		if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)
			dp->i_count = 0;
		else
			dp->i_count = dp->i_offset - prevoff;
		if (dd_ino != NULL)
			return (0);
		if (dp->i_number == ino) {
			VREF(vdp);
			*vpp = vdp;
			return (0);
		}
		if ((error = VFS_VGET(vdp->v_mount, ino, LK_EXCLUSIVE,
		    &tdp)) != 0)
			return (error);
		/*
		 * If directory is "sticky", then user must own
		 * the directory, or the file in it, else she
		 * may not delete it (unless she's root). This
		 * implements append-only directories.
		 */
		if ((dp->i_mode & ISVTX) &&
		    cred->cr_uid != 0 &&
		    cred->cr_uid != dp->i_uid &&
		    VTOI(tdp)->i_uid != cred->cr_uid) {
			vput(tdp);
			return (EPERM);
		}
		*vpp = tdp;
		return (0);
	}

	/*
	 * If rewriting (RENAME), return the inode and the
	 * information required to rewrite the present directory
	 * Must get inode of directory entry to verify it's a
	 * regular file, or empty directory.
	 */
	if (nameiop == RENAME && (flags & ISLASTCN)) {
		if ((error = VOP_ACCESS(vdp, VWRITE, cred, cnp->cn_thread)) != 0)
			return (error);
		/*
		 * Careful about locking second inode.
		 * This can only occur if the target is ".".
		 */
		if (dp->i_number == ino)
			return (EISDIR);
		if (dd_ino != NULL)
			return (0);
		if ((error = VFS_VGET(vdp->v_mount, ino, LK_EXCLUSIVE,
		    &tdp)) != 0)
			return (error);
		*vpp = tdp;
		cnp->cn_flags |= SAVENAME;
		return (0);
	}
	if (dd_ino != NULL)
		return (0);

	/*
	 * Step through the translation in the name.  We do not `vput' the
	 * directory because we may need it again if a symbolic link
	 * is relative to the current directory.  Instead we save it
	 * unlocked as "pdp".  We must get the target inode before unlocking
	 * the directory to insure that the inode will not be removed
	 * before we get it.  We prevent deadlock by always fetching
	 * inodes from the root, moving down the directory tree. Thus
	 * when following backward pointers ".." we must unlock the
	 * parent directory before getting the requested directory.
	 * There is a potential race condition here if both the current
	 * and parent directories are removed before the VFS_VGET for the
	 * inode associated with ".." returns.  We hope that this occurs
	 * infrequently since we cannot avoid this race condition without
	 * implementing a sophisticated deadlock detection algorithm.
	 * Note also that this simple deadlock detection scheme will not
	 * work if the file system has any hard links other than ".."
	 * that point backwards in the directory structure.
	 */
	pdp = vdp;
	if (flags & ISDOTDOT) {
		ltype = VOP_ISLOCKED(pdp);
		VOP_UNLOCK(pdp, 0);	/* race to get the inode */
		error = VFS_VGET(vdp->v_mount, ino, cnp->cn_lkflags, &tdp);
		vn_lock(pdp, ltype | LK_RETRY);
		if (pdp->v_iflag & VI_DOOMED) {
			if (error == 0)
				vput(tdp);
			error = ENOENT;
		}
		if (error)
			return (error);
		/*
		 * Recheck that ".." entry in the vdp directory points
		 * to the inode we looked up before vdp lock was
		 * dropped.
		 */
		error = ext2_lookup_ino(pdp, NULL, cnp, &ino1);
		if (error) {
			vput(tdp);
			return (error);
		}
		if (ino1 != ino) {
			vput(tdp);
			goto restart;
		}
		*vpp = tdp;
	} else if (dp->i_number == ino) {
		VREF(vdp);	/* we want ourself, ie "." */
		/*
		 * When we lookup "." we still can be asked to lock it
		 * differently.
		 */
		ltype = cnp->cn_lkflags & LK_TYPE_MASK;
		if (ltype != VOP_ISLOCKED(vdp)) {
			if (ltype == LK_EXCLUSIVE)
				vn_lock(vdp, LK_UPGRADE | LK_RETRY);
			else /* if (ltype == LK_SHARED) */
				vn_lock(vdp, LK_DOWNGRADE | LK_RETRY);
		}
		*vpp = vdp;
	} else {
		if ((error = VFS_VGET(vdp->v_mount, ino, cnp->cn_lkflags,
		    &tdp)) != 0)
			return (error);
		*vpp = tdp;
	}

	/*
	 * Insert name into cache if appropriate.
	 */
	if (cnp->cn_flags & MAKEENTRY)
		cache_enter(vdp, *vpp, cnp);
	return (0);
}

void
ext2_dirbad(struct inode *ip, doff_t offset, char *how)
{
	struct mount *mp;

	mp = ITOV(ip)->v_mount;
	if ((mp->mnt_flag & MNT_RDONLY) == 0)
		panic("ext2_dirbad: %s: bad dir ino %lu at offset %ld: %s\n",
			mp->mnt_stat.f_mntonname, (u_long)ip->i_number,(long)offset, how);
	else
	(void)printf("%s: bad dir ino %lu at offset %ld: %s\n",
            mp->mnt_stat.f_mntonname, (u_long)ip->i_number, (long)offset, how);

}

/*
 * Do consistency checking on a directory entry:
 *	record length must be multiple of 4
 *	entry must fit in rest of its DIRBLKSIZ block
 *	record must be large enough to contain entry
 *	name is not longer than MAXNAMLEN
 *	name must be as long as advertised, and null terminated
 */
/*
 *	changed so that it confirms to ext2_check_dir_entry
 */
static int
ext2_dirbadentry(struct vnode *dp, struct ext2fs_direct_2 *de,
    int entryoffsetinblock)
{
	int	DIRBLKSIZ = VTOI(dp)->i_e2fs->e2fs_bsize;

	char * error_msg = NULL;

	if (de->e2d_reclen < EXT2_DIR_REC_LEN(1))
		error_msg = "rec_len is smaller than minimal";
	else if (de->e2d_reclen % 4 != 0)
		error_msg = "rec_len % 4 != 0";
	else if (de->e2d_reclen < EXT2_DIR_REC_LEN(de->e2d_namlen))
		error_msg = "reclen is too small for name_len";
	else if (entryoffsetinblock + de->e2d_reclen > DIRBLKSIZ)
		error_msg = "directory entry across blocks";
	/* else LATER
	     if (de->inode > dir->i_sb->u.ext2_sb.s_es->s_inodes_count)
		error_msg = "inode out of bounds";
	*/

	if (error_msg != NULL) {
		printf("bad directory entry: %s\n", error_msg);
		printf("offset=%d, inode=%lu, rec_len=%u, name_len=%u\n",
			entryoffsetinblock, (unsigned long)de->e2d_ino,
			de->e2d_reclen, de->e2d_namlen);
	}
	return error_msg == NULL ? 0 : 1;
}

/*
 * Write a directory entry after a call to namei, using the parameters
 * that it left in nameidata.  The argument ip is the inode which the new
 * directory entry will refer to.  Dvp is a pointer to the directory to
 * be written, which was left locked by namei. Remaining parameters
 * (dp->i_offset, dp->i_count) indicate how the space for the new
 * entry is to be obtained.
 */
int
ext2_direnter(struct inode *ip, struct vnode *dvp, struct componentname *cnp)
{
	struct ext2fs_direct_2 *ep, *nep;
	struct inode *dp;
	struct buf *bp;
	struct ext2fs_direct_2 newdir;
	struct iovec aiov;
	struct uio auio;
	u_int dsize;
	int error, loc, newentrysize, spacefree;
	char *dirbuf;
	int     DIRBLKSIZ = ip->i_e2fs->e2fs_bsize;

#ifdef INVARIANTS
	if ((cnp->cn_flags & SAVENAME) == 0)
		panic("ext2_direnter: missing name");
#endif
	dp = VTOI(dvp);
	newdir.e2d_ino = ip->i_number;
	newdir.e2d_namlen = cnp->cn_namelen;
	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs,
	    EXT2F_INCOMPAT_FTYPE))
		newdir.e2d_type = DTTOFT(IFTODT(ip->i_mode));
	else
		newdir.e2d_type = EXT2_FT_UNKNOWN;
	bcopy(cnp->cn_nameptr, newdir.e2d_name, (unsigned)cnp->cn_namelen + 1);
	newentrysize = EXT2_DIR_REC_LEN(newdir.e2d_namlen);
	if (dp->i_count == 0) {
		/*
		 * If dp->i_count is 0, then namei could find no
		 * space in the directory. Here, dp->i_offset will
		 * be on a directory block boundary and we will write the
		 * new entry into a fresh block.
		 */
		if (dp->i_offset & (DIRBLKSIZ - 1))
			panic("ext2_direnter: newblk");
		auio.uio_offset = dp->i_offset;
		newdir.e2d_reclen = DIRBLKSIZ;
		auio.uio_resid = newentrysize;
		aiov.iov_len = newentrysize;
		aiov.iov_base = (caddr_t)&newdir;
		auio.uio_iov = &aiov;
		auio.uio_iovcnt = 1;
		auio.uio_rw = UIO_WRITE;
		auio.uio_segflg = UIO_SYSSPACE;
		auio.uio_td = (struct thread *)0;
		error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred);
		if (DIRBLKSIZ >
		    VFSTOEXT2(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
			/* XXX should grow with balloc() */
			panic("ext2_direnter: frag size");
		else if (!error) {
			dp->i_size = roundup2(dp->i_size, DIRBLKSIZ);
			dp->i_flag |= IN_CHANGE;
		}
		return (error);
	}

	/*
	 * If dp->i_count is non-zero, then namei found space
	 * for the new entry in the range dp->i_offset to
	 * dp->i_offset + dp->i_count in the directory.
	 * To use this space, we may have to compact the entries located
	 * there, by copying them together towards the beginning of the
	 * block, leaving the free space in one usable chunk at the end.
	 */

	/*
	 * Increase size of directory if entry eats into new space.
	 * This should never push the size past a new multiple of
	 * DIRBLKSIZE.
	 *
	 * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
	 */
	if (dp->i_offset + dp->i_count > dp->i_size)
		dp->i_size = dp->i_offset + dp->i_count;
	/*
	 * Get the block containing the space for the new directory entry.
	 */
	if ((error = ext2_blkatoff(dvp, (off_t)dp->i_offset, &dirbuf,
	    &bp)) != 0)
		return (error);
	/*
	 * Find space for the new entry. In the simple case, the entry at
	 * offset base will have the space. If it does not, then namei
	 * arranged that compacting the region dp->i_offset to
	 * dp->i_offset + dp->i_count would yield the
	 * space.
	 */
	ep = (struct ext2fs_direct_2 *)dirbuf;
	dsize = EXT2_DIR_REC_LEN(ep->e2d_namlen);
	spacefree = ep->e2d_reclen - dsize;
	for (loc = ep->e2d_reclen; loc < dp->i_count; ) {
		nep = (struct ext2fs_direct_2 *)(dirbuf + loc);
		if (ep->e2d_ino) {
			/* trim the existing slot */
			ep->e2d_reclen = dsize;
			ep = (struct ext2fs_direct_2 *)((char *)ep + dsize);
		} else {
			/* overwrite; nothing there; header is ours */
			spacefree += dsize;
		}
		dsize = EXT2_DIR_REC_LEN(nep->e2d_namlen);
		spacefree += nep->e2d_reclen - dsize;
		loc += nep->e2d_reclen;
		bcopy((caddr_t)nep, (caddr_t)ep, dsize);
	}
	/*
	 * Update the pointer fields in the previous entry (if any),
	 * copy in the new entry, and write out the block.
	 */
	if (ep->e2d_ino == 0) {
		if (spacefree + dsize < newentrysize)
			panic("ext2_direnter: compact1");
		newdir.e2d_reclen = spacefree + dsize;
	} else {
		if (spacefree < newentrysize)
			panic("ext2_direnter: compact2");
		newdir.e2d_reclen = spacefree;
		ep->e2d_reclen = dsize;
		ep = (struct ext2fs_direct_2 *)((char *)ep + dsize);
	}
	bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize);
	if (DOINGASYNC(dvp)) {
		bdwrite(bp);
		error = 0;
	} else {
		error = bwrite(bp);
	}
	dp->i_flag |= IN_CHANGE | IN_UPDATE;
	if (!error && dp->i_endoff && dp->i_endoff < dp->i_size)
		error = ext2_truncate(dvp, (off_t)dp->i_endoff, IO_SYNC,
		    cnp->cn_cred, cnp->cn_thread);
	return (error);
}

/*
 * Remove a directory entry after a call to namei, using
 * the parameters which it left in nameidata. The entry
 * dp->i_offset contains the offset into the directory of the
 * entry to be eliminated.  The dp->i_count field contains the
 * size of the previous record in the directory.  If this
 * is 0, the first entry is being deleted, so we need only
 * zero the inode number to mark the entry as free.  If the
 * entry is not the first in the directory, we must reclaim
 * the space of the now empty record by adding the record size
 * to the size of the previous entry.
 */
int
ext2_dirremove(struct vnode *dvp, struct componentname *cnp)
{
	struct inode *dp;
	struct ext2fs_direct_2 *ep, *rep;
	struct buf *bp;
	int error;

	dp = VTOI(dvp);
	if (dp->i_count == 0) {
		/*
		 * First entry in block: set d_ino to zero.
		 */
		if ((error =
		    ext2_blkatoff(dvp, (off_t)dp->i_offset, (char **)&ep,
		    &bp)) != 0)
			return (error);
		ep->e2d_ino = 0;
		error = bwrite(bp);
		dp->i_flag |= IN_CHANGE | IN_UPDATE;
		return (error);
	}
	/*
	 * Collapse new free space into previous entry.
	 */
	if ((error = ext2_blkatoff(dvp, (off_t)(dp->i_offset - dp->i_count),
	    (char **)&ep, &bp)) != 0)
		return (error);

	/* Set 'rep' to the entry being removed. */
	if (dp->i_count == 0)
		rep = ep;
	else
		rep = (struct ext2fs_direct_2 *)((char *)ep + ep->e2d_reclen);
	ep->e2d_reclen += rep->e2d_reclen;
	if (DOINGASYNC(dvp) && dp->i_count != 0)
		bdwrite(bp);
	else
		error = bwrite(bp);
	dp->i_flag |= IN_CHANGE | IN_UPDATE;
	return (error);
}

/*
 * Rewrite an existing directory entry to point at the inode
 * supplied.  The parameters describing the directory entry are
 * set up by a call to namei.
 */
int
ext2_dirrewrite(struct inode *dp, struct inode *ip, struct componentname *cnp)
{
	struct buf *bp;
	struct ext2fs_direct_2 *ep;
	struct vnode *vdp = ITOV(dp);
	int error;

	if ((error = ext2_blkatoff(vdp, (off_t)dp->i_offset, (char **)&ep,
	    &bp)) != 0)
		return (error);
	ep->e2d_ino = ip->i_number;
	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs,
	    EXT2F_INCOMPAT_FTYPE))
		ep->e2d_type = DTTOFT(IFTODT(ip->i_mode));
	else
		ep->e2d_type = EXT2_FT_UNKNOWN;
	error = bwrite(bp);
	dp->i_flag |= IN_CHANGE | IN_UPDATE;
	return (error);
}

/*
 * Check if a directory is empty or not.
 * Inode supplied must be locked.
 *
 * Using a struct dirtemplate here is not precisely
 * what we want, but better than using a struct direct.
 *
 * NB: does not handle corrupted directories.
 */
int
ext2_dirempty(struct inode *ip, ino_t parentino, struct ucred *cred)
{
	off_t off;
	struct dirtemplate dbuf;
	struct ext2fs_direct_2 *dp = (struct ext2fs_direct_2 *)&dbuf;
	int error, namlen;
	ssize_t count;
#define	MINDIRSIZ (sizeof(struct dirtemplate) / 2)

	for (off = 0; off < ip->i_size; off += dp->e2d_reclen) {
		error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ,
		    off, UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK, cred,
		    NOCRED, &count, (struct thread *)0);
		/*
		 * Since we read MINDIRSIZ, residual must
		 * be 0 unless we're at end of file.
		 */
		if (error || count != 0)
			return (0);
		/* avoid infinite loops */
		if (dp->e2d_reclen == 0)
			return (0);
		/* skip empty entries */
		if (dp->e2d_ino == 0)
			continue;
		/* accept only "." and ".." */
		namlen = dp->e2d_namlen;
		if (namlen > 2)
			return (0);
		if (dp->e2d_name[0] != '.')
			return (0);
		/*
		 * At this point namlen must be 1 or 2.
		 * 1 implies ".", 2 implies ".." if second
		 * char is also "."
		 */
		if (namlen == 1)
			continue;
		if (dp->e2d_name[1] == '.' && dp->e2d_ino == parentino)
			continue;
		return (0);
	}
	return (1);
}

/*
 * Check if source directory is in the path of the target directory.
 * Target is supplied locked, source is unlocked.
 * The target is always vput before returning.
 */
int
ext2_checkpath(struct inode *source, struct inode *target, struct ucred *cred)
{
	struct vnode *vp;
	int error, namlen;
	struct dirtemplate dirbuf;

	vp = ITOV(target);
	if (target->i_number == source->i_number) {
		error = EEXIST;
		goto out;
	}
	if (target->i_number == EXT2_ROOTINO) {
		error = 0;
		goto out;
	}

	for (;;) {
		if (vp->v_type != VDIR) {
			error = ENOTDIR;
			break;
		}
		error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
			sizeof(struct dirtemplate), (off_t)0, UIO_SYSSPACE,
			IO_NODELOCKED | IO_NOMACCHECK, cred, NOCRED, NULL,
			NULL);
		if (error != 0)
			break;
		namlen = dirbuf.dotdot_type;	/* like ufs little-endian */
		if (namlen != 2 ||
		    dirbuf.dotdot_name[0] != '.' ||
		    dirbuf.dotdot_name[1] != '.') {
			error = ENOTDIR;
			break;
		}
		if (dirbuf.dotdot_ino == source->i_number) {
			error = EINVAL;
			break;
		}
		if (dirbuf.dotdot_ino == EXT2_ROOTINO)
			break;
		vput(vp);
		if ((error = VFS_VGET(vp->v_mount, dirbuf.dotdot_ino,
		    LK_EXCLUSIVE, &vp)) != 0) {
			vp = NULL;
			break;
		}
	}

out:
	if (error == ENOTDIR)
		printf("checkpath: .. not a directory\n");
	if (vp != NULL)
		vput(vp);
	return (error);
}


text:
from .endpoint import BroadcastsEndpoint
from .schemas import Broadcast

__all__ = ["BroadcastsEndpoint", "Broadcast"]


text:
require "formula"

class Osxfuse < Formula
  homepage "http://osxfuse.github.io"
  url "https://github.com/osxfuse/osxfuse.git", :tag => "osxfuse-2.7.0"

  head "https://github.com/osxfuse/osxfuse.git", :branch => "osxfuse-2"

  bottle do
    sha1 "e96e12d2fe72a2a85f80b9c9b640229f269cdb82" => :mavericks
    sha1 "f3a10fed4401867107fcee6850f03301f1698f49" => :mountain_lion
    sha1 "a7b6d7d22f08d64efab35917c7ee2338a5487b22" => :lion
  end

  depends_on :macos => :snow_leopard
  depends_on :xcode => :build
  depends_on "autoconf" => :build
  depends_on "automake" => :build
  depends_on "libtool" => :build
  depends_on "gettext" => :build

  conflicts_with "fuse4x", :because => "both install `fuse.pc`"

  def install
    # Do not override Xcode build settings
    ENV.remove_cc_etc

    system "./build.sh", "-t", "homebrew", "-f", prefix
  end

  def caveats; <<-EOS.undent
    If upgrading from a previous version of osxfuse, the previous kernel extension
    will need to be unloaded before installing the new version. First, check that
    no FUSE-based file systems are running:

      mount -t osxfusefs

    Unmount all FUSE file systems and then unload the kernel extension:

      sudo kextunload -b com.github.osxfuse.filesystems.osxfusefs

    The new osxfuse file system bundle needs to be installed by the root user:

      sudo /bin/cp -RfX #{opt_prefix}/Library/Filesystems/osxfusefs.fs /Library/Filesystems/
      sudo chmod +s /Library/Filesystems/osxfusefs.fs/Support/load_osxfusefs
    EOS
  end
end


text:
import { Binary, OS } from './binary';
/**
 * The appium binary.
 */
export declare class Appium extends Binary {
    static os: OS[];
    static id: string;
    static versionDefault: string;
    static isDefault: boolean;
    static shortName: string[];
    constructor(alternateCDN?: string);
    id(): string;
    versionDefault(): string;
    executableSuffix(): string;
    remove(sdkPath: string): void;
}