text
stringlengths 54
60.6k
|
|---|
<commit_before>565d24a6-2e4e-11e5-9284-b827eb9e62be<commit_msg>5662343c-2e4e-11e5-9284-b827eb9e62be<commit_after>5662343c-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>6ca3d480-2e4e-11e5-9284-b827eb9e62be<commit_msg>6ca8e876-2e4e-11e5-9284-b827eb9e62be<commit_after>6ca8e876-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>4826cfea-2e4e-11e5-9284-b827eb9e62be<commit_msg>482bc888-2e4e-11e5-9284-b827eb9e62be<commit_after>482bc888-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c89bff6a-2e4e-11e5-9284-b827eb9e62be<commit_msg>c8a0f97a-2e4e-11e5-9284-b827eb9e62be<commit_after>c8a0f97a-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>99a72352-2e4d-11e5-9284-b827eb9e62be<commit_msg>99ac1fb0-2e4d-11e5-9284-b827eb9e62be<commit_after>99ac1fb0-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>3a576722-2e4d-11e5-9284-b827eb9e62be<commit_msg>3a5c6786-2e4d-11e5-9284-b827eb9e62be<commit_after>3a5c6786-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>537882a8-2e4e-11e5-9284-b827eb9e62be<commit_msg>537d94a0-2e4e-11e5-9284-b827eb9e62be<commit_after>537d94a0-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>1a865dfe-2e4d-11e5-9284-b827eb9e62be<commit_msg>1a8b6b64-2e4d-11e5-9284-b827eb9e62be<commit_after>1a8b6b64-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>a872b9cc-2e4e-11e5-9284-b827eb9e62be<commit_msg>a877d8c6-2e4e-11e5-9284-b827eb9e62be<commit_after>a877d8c6-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>65e3da64-2e4e-11e5-9284-b827eb9e62be<commit_msg>65e8e1bc-2e4e-11e5-9284-b827eb9e62be<commit_after>65e8e1bc-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>5144288a-2e4d-11e5-9284-b827eb9e62be<commit_msg>514984f6-2e4d-11e5-9284-b827eb9e62be<commit_after>514984f6-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>46fe1ba0-2e4e-11e5-9284-b827eb9e62be<commit_msg>47033072-2e4e-11e5-9284-b827eb9e62be<commit_after>47033072-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>3063ba48-2e4f-11e5-9284-b827eb9e62be<commit_msg>3068b386-2e4f-11e5-9284-b827eb9e62be<commit_after>3068b386-2e4f-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>cced9e9a-2e4c-11e5-9284-b827eb9e62be<commit_msg>ccf29300-2e4c-11e5-9284-b827eb9e62be<commit_after>ccf29300-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>7ee67b58-2e4d-11e5-9284-b827eb9e62be<commit_msg>7eeb6dac-2e4d-11e5-9284-b827eb9e62be<commit_after>7eeb6dac-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>0df3340e-2e4d-11e5-9284-b827eb9e62be<commit_msg>0df82798-2e4d-11e5-9284-b827eb9e62be<commit_after>0df82798-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>005dfe62-2e4f-11e5-9284-b827eb9e62be<commit_msg>0062fa5c-2e4f-11e5-9284-b827eb9e62be<commit_after>0062fa5c-2e4f-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c8b4f6d2-2e4e-11e5-9284-b827eb9e62be<commit_msg>c8b9fa42-2e4e-11e5-9284-b827eb9e62be<commit_after>c8b9fa42-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>d517b43e-2e4c-11e5-9284-b827eb9e62be<commit_msg>d51cbf10-2e4c-11e5-9284-b827eb9e62be<commit_after>d51cbf10-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>18bc116a-2e4f-11e5-9284-b827eb9e62be<commit_msg>18c11980-2e4f-11e5-9284-b827eb9e62be<commit_after>18c11980-2e4f-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c0d547a6-2e4d-11e5-9284-b827eb9e62be<commit_msg>c0da5b10-2e4d-11e5-9284-b827eb9e62be<commit_after>c0da5b10-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>17fba4a8-2e4e-11e5-9284-b827eb9e62be<commit_msg>1800942c-2e4e-11e5-9284-b827eb9e62be<commit_after>1800942c-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ca84ce48-2e4d-11e5-9284-b827eb9e62be<commit_msg>ca89beb2-2e4d-11e5-9284-b827eb9e62be<commit_after>ca89beb2-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>37e488e8-2e4e-11e5-9284-b827eb9e62be<commit_msg>37e98b86-2e4e-11e5-9284-b827eb9e62be<commit_after>37e98b86-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>d5a5b612-2e4c-11e5-9284-b827eb9e62be<commit_msg>d5aac2a6-2e4c-11e5-9284-b827eb9e62be<commit_after>d5aac2a6-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c66ab218-2e4e-11e5-9284-b827eb9e62be<commit_msg>c66faf0c-2e4e-11e5-9284-b827eb9e62be<commit_after>c66faf0c-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>370435b8-2e4e-11e5-9284-b827eb9e62be<commit_msg>3709319e-2e4e-11e5-9284-b827eb9e62be<commit_after>3709319e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>58a80b8c-2e4d-11e5-9284-b827eb9e62be<commit_msg>58ad07c2-2e4d-11e5-9284-b827eb9e62be<commit_after>58ad07c2-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>edd87b6a-2e4d-11e5-9284-b827eb9e62be<commit_msg>eddd820e-2e4d-11e5-9284-b827eb9e62be<commit_after>eddd820e-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>fdea11e8-2e4e-11e5-9284-b827eb9e62be<commit_msg>fdef0888-2e4e-11e5-9284-b827eb9e62be<commit_after>fdef0888-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>313e1488-2e4d-11e5-9284-b827eb9e62be<commit_msg>31430ca4-2e4d-11e5-9284-b827eb9e62be<commit_after>31430ca4-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>a527563e-2e4d-11e5-9284-b827eb9e62be<commit_msg>a52c4f54-2e4d-11e5-9284-b827eb9e62be<commit_after>a52c4f54-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>acd4487e-2e4d-11e5-9284-b827eb9e62be<commit_msg>acd942fc-2e4d-11e5-9284-b827eb9e62be<commit_after>acd942fc-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>124435ca-2e4e-11e5-9284-b827eb9e62be<commit_msg>12492a4e-2e4e-11e5-9284-b827eb9e62be<commit_after>12492a4e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>15681438-2e4e-11e5-9284-b827eb9e62be<commit_msg>156d0d6c-2e4e-11e5-9284-b827eb9e62be<commit_after>156d0d6c-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>2dfe2e7e-2e4e-11e5-9284-b827eb9e62be<commit_msg>2e034760-2e4e-11e5-9284-b827eb9e62be<commit_after>2e034760-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>a3c419e4-2e4d-11e5-9284-b827eb9e62be<commit_msg>a3c9164c-2e4d-11e5-9284-b827eb9e62be<commit_after>a3c9164c-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>1000ced2-2e4d-11e5-9284-b827eb9e62be<commit_msg>1005e0ca-2e4d-11e5-9284-b827eb9e62be<commit_after>1005e0ca-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>5fadbd28-2e4d-11e5-9284-b827eb9e62be<commit_msg>5fb2ce9e-2e4d-11e5-9284-b827eb9e62be<commit_after>5fb2ce9e-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>9d51bd54-2e4e-11e5-9284-b827eb9e62be<commit_msg>9d56c376-2e4e-11e5-9284-b827eb9e62be<commit_after>9d56c376-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>6aa15a72-2e4e-11e5-9284-b827eb9e62be<commit_msg>6aa65392-2e4e-11e5-9284-b827eb9e62be<commit_after>6aa65392-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>202cf538-2e4d-11e5-9284-b827eb9e62be<commit_msg>2031e868-2e4d-11e5-9284-b827eb9e62be<commit_after>2031e868-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c5b130be-2e4d-11e5-9284-b827eb9e62be<commit_msg>c5b638ac-2e4d-11e5-9284-b827eb9e62be<commit_after>c5b638ac-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>d3472ab2-2e4d-11e5-9284-b827eb9e62be<commit_msg>d34c2562-2e4d-11e5-9284-b827eb9e62be<commit_after>d34c2562-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>dc91c018-2e4e-11e5-9284-b827eb9e62be<commit_msg>dc96b74e-2e4e-11e5-9284-b827eb9e62be<commit_after>dc96b74e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>0d5e04cc-2e4f-11e5-9284-b827eb9e62be<commit_msg>0d62fc8e-2e4f-11e5-9284-b827eb9e62be<commit_after>0d62fc8e-2e4f-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>535a1840-2e4e-11e5-9284-b827eb9e62be<commit_msg>535f3410-2e4e-11e5-9284-b827eb9e62be<commit_after>535f3410-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>894c65b2-2e4d-11e5-9284-b827eb9e62be<commit_msg>8951590a-2e4d-11e5-9284-b827eb9e62be<commit_after>8951590a-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>b844b540-2e4d-11e5-9284-b827eb9e62be<commit_msg>b849a2e4-2e4d-11e5-9284-b827eb9e62be<commit_after>b849a2e4-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>139ab3b4-2e4d-11e5-9284-b827eb9e62be<commit_msg>13b0c1ae-2e4d-11e5-9284-b827eb9e62be<commit_after>13b0c1ae-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>53a66dc6-2e4e-11e5-9284-b827eb9e62be<commit_msg>53ab7f6e-2e4e-11e5-9284-b827eb9e62be<commit_after>53ab7f6e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>d107a190-2e4e-11e5-9284-b827eb9e62be<commit_msg>d10c9ec0-2e4e-11e5-9284-b827eb9e62be<commit_after>d10c9ec0-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ad66c61c-2e4e-11e5-9284-b827eb9e62be<commit_msg>ad6bc658-2e4e-11e5-9284-b827eb9e62be<commit_after>ad6bc658-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>5b02aecc-2e4e-11e5-9284-b827eb9e62be<commit_msg>5b07bbba-2e4e-11e5-9284-b827eb9e62be<commit_after>5b07bbba-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>abf06bb8-2e4d-11e5-9284-b827eb9e62be<commit_msg>abf56d48-2e4d-11e5-9284-b827eb9e62be<commit_after>abf56d48-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>f89c0fb2-2e4d-11e5-9284-b827eb9e62be<commit_msg>f8a1227c-2e4d-11e5-9284-b827eb9e62be<commit_after>f8a1227c-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>a18f5b06-2e4e-11e5-9284-b827eb9e62be<commit_msg>a19459c6-2e4e-11e5-9284-b827eb9e62be<commit_after>a19459c6-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>0ca600b2-2e4e-11e5-9284-b827eb9e62be<commit_msg>0caaf87e-2e4e-11e5-9284-b827eb9e62be<commit_after>0caaf87e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>3b975100-2e4e-11e5-9284-b827eb9e62be<commit_msg>3b9c5420-2e4e-11e5-9284-b827eb9e62be<commit_after>3b9c5420-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>55bd725e-2e4d-11e5-9284-b827eb9e62be<commit_msg>55c27a56-2e4d-11e5-9284-b827eb9e62be<commit_after>55c27a56-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>87d235e0-2e4d-11e5-9284-b827eb9e62be<commit_msg>87d73202-2e4d-11e5-9284-b827eb9e62be<commit_after>87d73202-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>964d35a2-2e4d-11e5-9284-b827eb9e62be<commit_msg>9669df36-2e4d-11e5-9284-b827eb9e62be<commit_after>9669df36-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ccfc76f4-2e4c-11e5-9284-b827eb9e62be<commit_msg>cd0169c0-2e4c-11e5-9284-b827eb9e62be<commit_after>cd0169c0-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ccd9bd4e-2e4c-11e5-9284-b827eb9e62be<commit_msg>ccdebe48-2e4c-11e5-9284-b827eb9e62be<commit_after>ccdebe48-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>c1e53288-2e4c-11e5-9284-b827eb9e62be<commit_msg>c1ea2720-2e4c-11e5-9284-b827eb9e62be<commit_after>c1ea2720-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>84320f4a-2e4e-11e5-9284-b827eb9e62be<commit_msg>84373d4e-2e4e-11e5-9284-b827eb9e62be<commit_after>84373d4e-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>1b962bd2-2e4f-11e5-9284-b827eb9e62be<commit_msg>1b9b3690-2e4f-11e5-9284-b827eb9e62be<commit_after>1b9b3690-2e4f-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>772faff6-2e4d-11e5-9284-b827eb9e62be<commit_msg>77349e62-2e4d-11e5-9284-b827eb9e62be<commit_after>77349e62-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ccacc2e4-2e4c-11e5-9284-b827eb9e62be<commit_msg>ccb1b70e-2e4c-11e5-9284-b827eb9e62be<commit_after>ccb1b70e-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ae0e36ce-2e4c-11e5-9284-b827eb9e62be<commit_msg>ae13233c-2e4c-11e5-9284-b827eb9e62be<commit_after>ae13233c-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>/****************************************************************/
/* DO NOT MODIFY THIS HEADER */
/* MOOSE - Multiphysics Object Oriented Simulation Environment */
/* */
/* (c) 2010 Battelle Energy Alliance, LLC */
/* ALL RIGHTS RESERVED */
/* */
/* Prepared by Battelle Energy Alliance, LLC */
/* Under Contract No. DE-AC07-05ID14517 */
/* With the U. S. Department of Energy */
/* */
/* See COPYRIGHT for full restrictions */
/****************************************************************/
#include "Convection.h"
/**
* This function defines the valid parameters for
* this Kernel and their default values
*/
template<>
InputParameters validParams<Convection>()
{
InputParameters params = validParams<Kernel>();
params.addRequiredParam<RealVectorValue>("velocity", "Velocity Vector");
return params;
}
Convection::Convection(const std::string & name,
InputParameters parameters)
// You must call the constructor of the base class first
:Kernel(name, parameters),
_velocity(getParam<RealVectorValue>("velocity"))
{}
Real Convection::computeQpResidual()
{
// velocity * _grad_u[_qp] is actually doing a dot product
return _test[_i][_qp]*(_velocity*_grad_u[_qp]);
}
Real Convection::computeQpJacobian()
{
// the partial derivative of _grad_u is just _grad_phi[_j]
return _test[_i][_qp]*(_velocity*_grad_phi[_j][_qp]);
}
<commit_msg>Make slides match code in ex2.<commit_after>/****************************************************************/
/* DO NOT MODIFY THIS HEADER */
/* MOOSE - Multiphysics Object Oriented Simulation Environment */
/* */
/* (c) 2010 Battelle Energy Alliance, LLC */
/* ALL RIGHTS RESERVED */
/* */
/* Prepared by Battelle Energy Alliance, LLC */
/* Under Contract No. DE-AC07-05ID14517 */
/* With the U. S. Department of Energy */
/* */
/* See COPYRIGHT for full restrictions */
/****************************************************************/
#include "Convection.h"
/**
* This function defines the valid parameters for
* this Kernel and their default values
*/
template<>
InputParameters validParams<Convection>()
{
InputParameters params = validParams<Kernel>();
params.addRequiredParam<RealVectorValue>("velocity", "Velocity Vector");
return params;
}
Convection::Convection(const std::string & name,
InputParameters parameters) :
// You must call the constructor of the base class first
Kernel(name, parameters),
_velocity(getParam<RealVectorValue>("velocity"))
{}
Real Convection::computeQpResidual()
{
// velocity * _grad_u[_qp] is actually doing a dot product
return _test[_i][_qp]*(_velocity*_grad_u[_qp]);
}
Real Convection::computeQpJacobian()
{
// the partial derivative of _grad_u is just _grad_phi[_j]
return _test[_i][_qp]*(_velocity*_grad_phi[_j][_qp]);
}
<|endoftext|> |
<commit_before>9bd59806-2e4e-11e5-9284-b827eb9e62be<commit_msg>9bda9176-2e4e-11e5-9284-b827eb9e62be<commit_after>9bda9176-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>8ea357d6-2e4e-11e5-9284-b827eb9e62be<commit_msg>8ea8623a-2e4e-11e5-9284-b827eb9e62be<commit_after>8ea8623a-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>dec9b78e-2e4c-11e5-9284-b827eb9e62be<commit_msg>decea5a0-2e4c-11e5-9284-b827eb9e62be<commit_after>decea5a0-2e4c-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>143f3d4e-2e4d-11e5-9284-b827eb9e62be<commit_msg>144450f4-2e4d-11e5-9284-b827eb9e62be<commit_after>144450f4-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>5f80096e-2e4d-11e5-9284-b827eb9e62be<commit_msg>5f851e04-2e4d-11e5-9284-b827eb9e62be<commit_after>5f851e04-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>ac190e82-2e4e-11e5-9284-b827eb9e62be<commit_msg>ac1e05ea-2e4e-11e5-9284-b827eb9e62be<commit_after>ac1e05ea-2e4e-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>1b2920fc-2e4d-11e5-9284-b827eb9e62be<commit_msg>1b2e2f7a-2e4d-11e5-9284-b827eb9e62be<commit_after>1b2e2f7a-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before>764ef268-2e4d-11e5-9284-b827eb9e62be<commit_msg>76543caa-2e4d-11e5-9284-b827eb9e62be<commit_after>76543caa-2e4d-11e5-9284-b827eb9e62be<|endoftext|> |
<commit_before><?hh
class StringTemplates {
public static (string, string) $Wrappers = tuple('{', '}');
public static function Render(string $Content, array $Parameters): string {
return preg_replace_callback('/'. static::$Wrappers[0] . '([\w\.]+)' . static::$Wrappers[1] .'/', function($matches) use ($Parameters) {
if (strpos($matches[1], '.') === false) {
return array_key_exists($matches[1], $Parameters) ? $Parameters[$matches[1]] : $matches[0];
} else {
$Subject = $Parameters;
foreach(explode('.', $matches[1]) as $Chunk) {
if (array_key_exists($Chunk, $Subject)) {
$Subject = $Subject[$Chunk];
} else return '';
}
if (!is_string($Subject) && !is_numeric($Subject) && !($Subject instanceof Stringish)) {
throw new Exception('Can not use non-stringish value into template: ' . $matches[1]);
}
return (string) $Subject;
}
}, $Content);
}
}
echo StringTemplates::Render('Hello {name}, I am {greet.message} to meet you', [
'name' => 'steel',
'greet' => [
'message' => 'honored'
]
]), "\n";
<commit_msg>:new: Add support for passing wrappers<commit_after><?hh
class StringTemplates {
public static (string, string) $Wrappers = tuple('{', '}');
public static function Render(string $Content, array $Parameters, ?(string, string) $Wrappers = null): string {
if ($Wrappers == null) {
$Wrappers = static::$Wrappers;
}
return preg_replace_callback('/\\'. $Wrappers[0] . '([\w\.]+)\\' . $Wrappers[1] .'/', function($matches) use ($Parameters) {
if (strpos($matches[1], '.') === false) {
return array_key_exists($matches[1], $Parameters) ? $Parameters[$matches[1]] : $matches[0];
} else {
$Subject = $Parameters;
foreach(explode('.', $matches[1]) as $Chunk) {
if (array_key_exists($Chunk, $Subject)) {
$Subject = $Subject[$Chunk];
} else return '';
}
if (!is_string($Subject) && !is_numeric($Subject) && !($Subject instanceof Stringish)) {
throw new Exception('Can not use non-stringish value into template: ' . $matches[1]);
}
return (string) $Subject;
}
}, $Content);
}
}
<|endoftext|> |
<commit_before>/*
* RBBallRecorder.cpp
* golf
*
* Created by Robert Rose on 10/10/08.
* Copyright 2008 Bork 3D LLC. All rights reserved.
*
*/
#include "RBBallRecorder.h"
#include "RudeGL.h"
#include "RudeTextureManager.h"
RBBallRecorder::RBBallRecorder()
: m_wrapped(false)
, m_curBallPosition(0)
, m_timer(0.0f)
, m_lastTime(0.0f)
{
m_tracerTexture = RudeTextureManager::GetInstance()->LoadTextureFromPVRTFile("tracer");
}
RBBallRecorder::~RBBallRecorder()
{
}
void RBBallRecorder::Reset()
{
m_wrapped = false;
m_curBallPosition = 0;
m_timer = 0.0f;
m_lastTime = 0.0f;
}
void RBBallRecorder::NextFrame(float delta, bool record)
{
if(!m_ball)
return;
if(delta <= 0.0f)
return;
m_timer += delta;
if(!record)
return;
float timeDelta = m_timer - m_lastTime;
m_lastTime = m_timer;
if(timeDelta <= 0.0f)
return;
m_ballPositions[m_curBallPosition].m_position = m_ball->GetPosition();
m_ballPositions[m_curBallPosition].m_angVel = m_ball->GetAngularVelocity();
m_ballPositions[m_curBallPosition].m_time = timeDelta;
m_curBallPosition++;
if(m_curBallPosition >= kNumBallPositions)
{
m_wrapped = true;
m_curBallPosition = 0;
}
}
void RBBallRecorder::RenderTracers()
{
float scale = m_ball->GetBallScale();
const float kTracerTimeLen = 0.5f;
float time = 0.0f;
int tracerLen = 0;
int k = m_curBallPosition - 1;
while(time < kTracerTimeLen)
{
time += m_ballPositions[k].m_time;
k--;
if(k < 0)
{
if(m_wrapped)
k = kNumBallPositions - 1;
else
break;
}
tracerLen++;
}
if(tracerLen == 0)
return;
RGL.Enable(kDepthTest, true);
RudeTextureManager::GetInstance()->SetTexture(m_tracerTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
RGL.EnableClient(kVertexArray, true);
RGL.EnableClient(kColorArray, true);
RGL.EnableClient(kTextureCoordArray, true);
const unsigned int colors[4] = {
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF
};
RGL.LoadIdentity();
int i = m_curBallPosition - 1;
int c = tracerLen;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
int p = i;
bool first = true;
btVector3 b1;
btVector3 b2;
float bintensity = 1.0f;
btVector3 right;
while(c)
{
if(p != i)
{
btVector3 p1 = m_ballPositions[p].m_position;
btVector3 p2 = m_ballPositions[i].m_position;
float aintensity = ((float) c) / ((float) tracerLen);
btVector3 dir = p2 - p1;
if(dir.length() > 0.0f)
{
dir = dir.normalize();
btVector3 up(0,1,0);
right = dir.cross(up);
}
right = right.normalize();
right *= scale;
btVector3 a1 = p1 + right;
btVector3 a2 = p1 - right;
if(first)
{
b1 = p2 + right;
b2 = p2 - right;
bintensity = ((float) c-1) / ((float) tracerLen);
first = false;
}
GLfloat point[] = {
a1.x(), a1.y(), a1.z(),
a2.x(), a2.y(), a2.z(),
b2.x(), b2.y(), b2.z(),
b1.x(), b1.y(), b1.z()
};
GLfloat uvs[] = {
0.0f, aintensity,
1.0f, aintensity,
1.0f, bintensity,
0.0f, bintensity,
};
glVertexPointer(3, GL_FLOAT, 0, point);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glTexCoordPointer(2, GL_FLOAT, 0, uvs);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
b1 = a1;
b2 = a2;
bintensity = aintensity;
}
p = i;
i--;
c--;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
}
}
/*
void RBBallRecorder::RenderTracers()
{
float scale = m_ball->GetBallScale();
glDisable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
RGL.LoadIdentity();
const int kTracerLen = 10;
int i = m_curBallPosition - 1;
int c = kTracerLen;
int p = i;
bool first = true;
btVector3 b1;
btVector3 b2;
unsigned int lasta = 0x00;
while(c)
{
if(p != i)
{
btVector3 p1 = m_ballPositions[p].m_position;
btVector3 p2 = m_ballPositions[i].m_position;
float intensity = ((float) c) / ((float) kTracerLen);
btVector3 dir = p2 - p1;
dir = dir.normalize();
btVector3 up(0,1,0);
btVector3 right = dir.cross(up);
right = right.normalize();
right *= scale * intensity;
btVector3 a1 = p1 + right;
btVector3 a2 = p1 - right;
if(first)
{
b1 = p2 + right;
b2 = p2 - right;
first = false;
}
GLfloat point[] = {
a1.x(), a1.y(), a1.z(),
a2.x(), a2.y(), a2.z(),
b2.x(), b2.y(), b2.z(),
b1.x(), b1.y(), b1.z()
};
unsigned int a = int(intensity * 0xFF) << 24;
unsigned int colors[] = {
a | 0xFFFFFF,
a | 0xFFFFFF,
lasta | 0xFFFFFF,
lasta | 0xFFFFFF
};
glVertexPointer(3, GL_FLOAT, 0, point);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
b1 = a1;
b2 = a2;
lasta = a;
}
p = i;
i--;
c--;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
}
}
*/
void RBBallRecorder::RenderRecords()
{
int last = m_curBallPosition;
if(m_wrapped)
last = kNumBallPositions - 1;
for(int i = 0; i < last; i++)
{
RGL.LoadIdentity();
m_ball->Render(m_ballPositions[i].m_position, m_ballPositions[i].m_angVel * m_timer * 0.2f);
}
}
<commit_msg>fixed rendering issues with ball recorder.. disabled backface culling, fixed more of the flickering<commit_after>/*
* RBBallRecorder.cpp
* golf
*
* Created by Robert Rose on 10/10/08.
* Copyright 2008 Bork 3D LLC. All rights reserved.
*
*/
#include "RBBallRecorder.h"
#include "RudeGL.h"
#include "RudeTextureManager.h"
RBBallRecorder::RBBallRecorder()
: m_wrapped(false)
, m_curBallPosition(0)
, m_timer(0.0f)
, m_lastTime(0.0f)
{
m_tracerTexture = RudeTextureManager::GetInstance()->LoadTextureFromPVRTFile("tracer");
}
RBBallRecorder::~RBBallRecorder()
{
}
void RBBallRecorder::Reset()
{
m_wrapped = false;
m_curBallPosition = 0;
m_timer = 0.0f;
m_lastTime = 0.0f;
}
void RBBallRecorder::NextFrame(float delta, bool record)
{
if(!m_ball)
return;
if(delta <= 0.0f)
return;
m_timer += delta;
if(!record)
return;
float timeDelta = m_timer - m_lastTime;
m_lastTime = m_timer;
if(timeDelta <= 0.0f)
return;
m_ballPositions[m_curBallPosition].m_position = m_ball->GetPosition();
m_ballPositions[m_curBallPosition].m_angVel = m_ball->GetAngularVelocity();
m_ballPositions[m_curBallPosition].m_time = timeDelta;
m_curBallPosition++;
if(m_curBallPosition >= kNumBallPositions)
{
m_wrapped = true;
m_curBallPosition = 0;
}
}
void RBBallRecorder::RenderTracers()
{
float scale = m_ball->GetBallScale();
const float kTracerTimeLen = 0.5f;
float time = 0.0f;
int tracerLen = 0;
int k = m_curBallPosition - 1;
while(time < kTracerTimeLen)
{
if(k < 0)
{
if(m_wrapped)
k = kNumBallPositions - 1;
else
break;
}
if(k == m_curBallPosition)
// we've wrapped all the way back around to the beginning
break;
time += m_ballPositions[k].m_time;
k--;
tracerLen++;
}
if(tracerLen == 0)
return;
RGL.Enable(kDepthTest, true);
RGL.Enable(kBackfaceCull, false);
RudeTextureManager::GetInstance()->SetTexture(m_tracerTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
RGL.EnableClient(kVertexArray, true);
RGL.EnableClient(kColorArray, true);
RGL.EnableClient(kTextureCoordArray, true);
const unsigned int colors[4] = {
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF
};
RGL.LoadIdentity();
int i = m_curBallPosition - 1;
int c = tracerLen;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
int p = i;
bool first = true;
btVector3 b1;
btVector3 b2;
float bintensity = 1.0f;
btVector3 right;
while(c)
{
if(p != i)
{
btVector3 p1 = m_ballPositions[p].m_position;
btVector3 p2 = m_ballPositions[i].m_position;
float aintensity = ((float) c) / ((float) tracerLen);
btVector3 dir = p2 - p1;
if(dir.length() > 0.0f)
{
dir = dir.normalize();
btVector3 up(0,1,0);
right = dir.cross(up);
}
right = right.normalize();
right *= scale;
btVector3 a1 = p1 + right;
btVector3 a2 = p1 - right;
if(first)
{
b1 = p2 + right;
b2 = p2 - right;
bintensity = ((float) c-1) / ((float) tracerLen);
first = false;
}
GLfloat point[] = {
a1.x(), a1.y(), a1.z(),
a2.x(), a2.y(), a2.z(),
b2.x(), b2.y(), b2.z(),
b1.x(), b1.y(), b1.z()
};
GLfloat uvs[] = {
0.0f, aintensity,
1.0f, aintensity,
1.0f, bintensity,
0.0f, bintensity,
};
glVertexPointer(3, GL_FLOAT, 0, point);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glTexCoordPointer(2, GL_FLOAT, 0, uvs);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
b1 = a1;
b2 = a2;
bintensity = aintensity;
}
p = i;
i--;
c--;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
}
}
/*
void RBBallRecorder::RenderTracers()
{
float scale = m_ball->GetBallScale();
glDisable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
RGL.LoadIdentity();
const int kTracerLen = 10;
int i = m_curBallPosition - 1;
int c = kTracerLen;
int p = i;
bool first = true;
btVector3 b1;
btVector3 b2;
unsigned int lasta = 0x00;
while(c)
{
if(p != i)
{
btVector3 p1 = m_ballPositions[p].m_position;
btVector3 p2 = m_ballPositions[i].m_position;
float intensity = ((float) c) / ((float) kTracerLen);
btVector3 dir = p2 - p1;
dir = dir.normalize();
btVector3 up(0,1,0);
btVector3 right = dir.cross(up);
right = right.normalize();
right *= scale * intensity;
btVector3 a1 = p1 + right;
btVector3 a2 = p1 - right;
if(first)
{
b1 = p2 + right;
b2 = p2 - right;
first = false;
}
GLfloat point[] = {
a1.x(), a1.y(), a1.z(),
a2.x(), a2.y(), a2.z(),
b2.x(), b2.y(), b2.z(),
b1.x(), b1.y(), b1.z()
};
unsigned int a = int(intensity * 0xFF) << 24;
unsigned int colors[] = {
a | 0xFFFFFF,
a | 0xFFFFFF,
lasta | 0xFFFFFF,
lasta | 0xFFFFFF
};
glVertexPointer(3, GL_FLOAT, 0, point);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
b1 = a1;
b2 = a2;
lasta = a;
}
p = i;
i--;
c--;
if(i < 0)
{
if(m_wrapped)
i = kNumBallPositions - 1;
else
c = 0;
}
}
}
*/
void RBBallRecorder::RenderRecords()
{
int last = m_curBallPosition;
if(m_wrapped)
last = kNumBallPositions - 1;
for(int i = 0; i < last; i++)
{
RGL.LoadIdentity();
m_ball->Render(m_ballPositions[i].m_position, m_ballPositions[i].m_angVel * m_timer * 0.2f);
}
}
<|endoftext|> |
<commit_before>// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2021 Intel Corporation. All Rights Reserved.
//#cmake: static!
//#cmake:add-file ../../../src/proc/sse/sse-pointcloud.cpp
#include "../algo-common.h"
#include <librealsense2/rsutil.h>
#include "../src/proc/sse/sse-pointcloud.h"
#include "../src/cuda/cuda-pointcloud.cuh"
#include "../src/types.h"
rs2_intrinsics intrin
= { 1280,
720,
643.720581f,
357.821259f,
904.170471f,
905.155090f,
RS2_DISTORTION_INVERSE_BROWN_CONRADY,
{ 0.180086836f, -0.534179211f, -0.00139013783f, 0.000118769123f, 0.470662683f } };
void compare(librealsense::float2 pixel1, librealsense::float2 pixel2)
{
for (auto i = 0; i < 2; i++)
{
CAPTURE(i);
REQUIRE(std::abs(pixel1[i] - pixel2[i]) <= 0.001);
}
}
TEST_CASE( "inverse_brown_conrady_deproject" )
{
float point[3] = { 0 };
librealsense::float2 pixel1 = { 1, 1 };
librealsense::float2 pixel2 = { 0, 0 };
float depth = 10.5;
rs2_deproject_pixel_to_point( point, &intrin, (float*)&pixel1, depth );
rs2_project_point_to_pixel((float*)&pixel2, &intrin, point );
compare(pixel1, pixel2);
}
TEST_CASE( "brown_conrady_deproject" )
{
float point[3] = { 0 };
librealsense::float2 pixel1 = { 1, 1 };
librealsense::float2 pixel2 = { 0, 0 };
float depth = 10.5;
rs2_deproject_pixel_to_point( point, &intrin, (float*)&pixel1, depth );
rs2_project_point_to_pixel((float*)&pixel2, &intrin, point );
compare(pixel1, pixel2);
}
#ifdef __SSSE3__
TEST_CASE("inverse_brown_conrady_sse_deproject")
{
std::shared_ptr<librealsense::pointcloud_sse> pc_sse = std::make_shared<librealsense::pointcloud_sse >();
librealsense::float2 pixel[4] = { {1, 1}, {0,2},{1,3},{1,4} };
float depth = 10.5;
librealsense::float3 points[4] = {};
// deproject with native code because sse deprojection doesn't implement distortion
for (auto i = 0; i < 4; i++)
{
rs2_deproject_pixel_to_point((float*)&points[i], &intrin, (float*)&pixel[i], depth);
}
std::vector<librealsense::float2> res(4, { 0,0 });
std::vector<librealsense::float2> unnormalized_res(4, { 0,0 });
rs2_extrinsics extrin = { {1,0,0,
0,1,0,
0,0,1},{0,0,0} };
pc_sse->get_texture_map_sse((librealsense::float2*)res.data(), points, 4, 1, intrin, extrin, (librealsense::float2*)unnormalized_res.data());
for (auto i = 0; i < 4; i++)
{
compare(unnormalized_res[i], pixel[i]);
}
}
TEST_CASE("brown_conrady_sse_deproject")
{
std::shared_ptr<librealsense::pointcloud_sse> pc_sse = std::make_shared<librealsense::pointcloud_sse >();
librealsense::float2 pixel[4] = { {1, 1}, {0,2},{1,3},{1,4} };
float depth = 10.5;
librealsense::float3 points[4] = {};
// deproject with native code because sse deprojection doesn't implement distortion
for (auto i = 0; i < 4; i++)
{
rs2_deproject_pixel_to_point((float*)&points[i], &intrin, (float*)&pixel[i], depth);
}
std::vector<librealsense::float2> res(4, { 0,0 });
std::vector<librealsense::float2> unnormalized_res(4, { 0,0 });
rs2_extrinsics extrin = { {1,0,0,
0,1,0,
0,0,1},{0,0,0} };
pc_sse->get_texture_map_sse((librealsense::float2*)res.data(), points, 4, 1, intrin, extrin, (librealsense::float2*)unnormalized_res.data());
for (auto i = 0; i < 4; i++)
{
compare(unnormalized_res[i], pixel[i]);
}
}
#endif
#ifdef RS2_USE_CUDA
TEST_CASE("inverse_brown_conrady_cuda_deproject")
{
std::vector<float3> point(1280 * 720, { 0,0,0 });
librealsense::float2 pixel = { 0, 0 };
std::vector<uint16_t> depth(1280 * 720, 1000);
rscuda::deproject_depth_cuda((float*)point.data(), intrin, depth.data(), 1);
for (auto i = 0; i < 720; i++)
{
for (auto j = 0; j < 1280; j++)
{
CAPTURE(i, j);
rs2_project_point_to_pixel((float*)&pixel, &intrin, (float*)&point[i* 1280 +j]);
compare({ (float)j,(float)i }, pixel);
}
}
}
TEST_CASE("brown_conrady_cuda_deproject")
{
std::vector<float3> point(1280 * 720, { 0,0,0 });
librealsense::float2 pixel = { 0, 0 };
std::vector<uint16_t> depth(1280 * 720, 1000);
rscuda::deproject_depth_cuda((float*)point.data(), intrin, depth.data(), 1);
for (auto i = 0; i < 720; i++)
{
for (auto j = 0; j < 1280; j++)
{
CAPTURE(i, j);
rs2_project_point_to_pixel((float*)&pixel, &intrin, (float*)&point[i * 1280 + j]);
compare({ (float)j,(float)i }, pixel);
}
}
}
#endif<commit_msg>Remove sse unit tests for now due to failure on LibCi<commit_after>// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2021 Intel Corporation. All Rights Reserved.
//#cmake: static!
//#cmake:add-file ../../../src/proc/sse/sse-pointcloud.cpp
#include "../algo-common.h"
#include <librealsense2/rsutil.h>
#include "../src/proc/sse/sse-pointcloud.h"
#include "../src/cuda/cuda-pointcloud.cuh"
#include "../src/types.h"
rs2_intrinsics intrin
= { 1280,
720,
643.720581f,
357.821259f,
904.170471f,
905.155090f,
RS2_DISTORTION_INVERSE_BROWN_CONRADY,
{ 0.180086836f, -0.534179211f, -0.00139013783f, 0.000118769123f, 0.470662683f } };
void compare(librealsense::float2 pixel1, librealsense::float2 pixel2)
{
for (auto i = 0; i < 2; i++)
{
CAPTURE(i);
REQUIRE(std::abs(pixel1[i] - pixel2[i]) <= 0.001);
}
}
TEST_CASE( "inverse_brown_conrady_deproject" )
{
float point[3] = { 0 };
librealsense::float2 pixel1 = { 1, 1 };
librealsense::float2 pixel2 = { 0, 0 };
float depth = 10.5;
rs2_deproject_pixel_to_point( point, &intrin, (float*)&pixel1, depth );
rs2_project_point_to_pixel((float*)&pixel2, &intrin, point );
compare(pixel1, pixel2);
}
TEST_CASE( "brown_conrady_deproject" )
{
float point[3] = { 0 };
librealsense::float2 pixel1 = { 1, 1 };
librealsense::float2 pixel2 = { 0, 0 };
float depth = 10.5;
rs2_deproject_pixel_to_point( point, &intrin, (float*)&pixel1, depth );
rs2_project_point_to_pixel((float*)&pixel2, &intrin, point );
compare(pixel1, pixel2);
}
#ifdef false
TEST_CASE("inverse_brown_conrady_sse_deproject")
{
std::shared_ptr<librealsense::pointcloud_sse> pc_sse = std::make_shared<librealsense::pointcloud_sse >();
librealsense::float2 pixel[4] = { {1, 1}, {0,2},{1,3},{1,4} };
float depth = 10.5;
librealsense::float3 points[4] = {};
// deproject with native code because sse deprojection doesn't implement distortion
for (auto i = 0; i < 4; i++)
{
rs2_deproject_pixel_to_point((float*)&points[i], &intrin, (float*)&pixel[i], depth);
}
std::vector<librealsense::float2> res(4, { 0,0 });
std::vector<librealsense::float2> unnormalized_res(4, { 0,0 });
rs2_extrinsics extrin = { {1,0,0,
0,1,0,
0,0,1},{0,0,0} };
pc_sse->get_texture_map_sse((librealsense::float2*)res.data(), points, 4, 1, intrin, extrin, (librealsense::float2*)unnormalized_res.data());
for (auto i = 0; i < 4; i++)
{
compare(unnormalized_res[i], pixel[i]);
}
}
TEST_CASE("brown_conrady_sse_deproject")
{
std::shared_ptr<librealsense::pointcloud_sse> pc_sse = std::make_shared<librealsense::pointcloud_sse >();
librealsense::float2 pixel[4] = { {1, 1}, {0,2},{1,3},{1,4} };
float depth = 10.5;
librealsense::float3 points[4] = {};
// deproject with native code because sse deprojection doesn't implement distortion
for (auto i = 0; i < 4; i++)
{
rs2_deproject_pixel_to_point((float*)&points[i], &intrin, (float*)&pixel[i], depth);
}
std::vector<librealsense::float2> res(4, { 0,0 });
std::vector<librealsense::float2> unnormalized_res(4, { 0,0 });
rs2_extrinsics extrin = { {1,0,0,
0,1,0,
0,0,1},{0,0,0} };
pc_sse->get_texture_map_sse((librealsense::float2*)res.data(), points, 4, 1, intrin, extrin, (librealsense::float2*)unnormalized_res.data());
for (auto i = 0; i < 4; i++)
{
compare(unnormalized_res[i], pixel[i]);
}
}
#endif
#ifdef RS2_USE_CUDA
TEST_CASE("inverse_brown_conrady_cuda_deproject")
{
std::vector<float3> point(1280 * 720, { 0,0,0 });
librealsense::float2 pixel = { 0, 0 };
std::vector<uint16_t> depth(1280 * 720, 1000);
rscuda::deproject_depth_cuda((float*)point.data(), intrin, depth.data(), 1);
for (auto i = 0; i < 720; i++)
{
for (auto j = 0; j < 1280; j++)
{
CAPTURE(i, j);
rs2_project_point_to_pixel((float*)&pixel, &intrin, (float*)&point[i* 1280 +j]);
compare({ (float)j,(float)i }, pixel);
}
}
}
TEST_CASE("brown_conrady_cuda_deproject")
{
std::vector<float3> point(1280 * 720, { 0,0,0 });
librealsense::float2 pixel = { 0, 0 };
std::vector<uint16_t> depth(1280 * 720, 1000);
rscuda::deproject_depth_cuda((float*)point.data(), intrin, depth.data(), 1);
for (auto i = 0; i < 720; i++)
{
for (auto j = 0; j < 1280; j++)
{
CAPTURE(i, j);
rs2_project_point_to_pixel((float*)&pixel, &intrin, (float*)&point[i * 1280 + j]);
compare({ (float)j,(float)i }, pixel);
}
}
}
#endif<|endoftext|> |
<commit_before>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*!
* Copyright (c) 2017 by Contributors
* \file quantized_pooling.cc
*/
#include <mxnet/op_attr_types.h>
#include "../nn/pooling-inl.h"
namespace mxnet {
namespace op {
bool QuantizedPoolingShape(const nnvm::NodeAttrs& attrs,
std::vector<TShape> *in_shape,
std::vector<TShape> *out_shape) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK_EQ(in_shape->size(), 3U);
if (shape_is_none(in_shape->at(0))) return false;
const TShape &dshape = (*in_shape)[0];
CHECK_EQ(dshape.ndim(), 4U)
<< "quantized_pooling: Input data should be 4D in "
<< "(batch, channel, y, x)";
// NCHW layout
const int N = 0, H = 2, W = 3, C = 1;
TShape oshape(4);
CHECK_EQ(param.kernel.ndim(), 2) << "QuantizedPoolingOp only supports 2D pooling for now";
CHECK(param.kernel[0] <= dshape[H] + 2 * param.pad[0])
<< "kernel size (" << param.kernel[0]
<< ") exceeds input (" << dshape[H]
<< " padded to " << (dshape[H] + 2*param.pad[0]) << ")";
CHECK(param.kernel[1] <= dshape[W] + 2 * param.pad[1])
<< "kernel size (" << param.kernel[1]
<< ") exceeds input (" << dshape[W]
<< " padded to " << (dshape[W] + 2*param.pad[1]) << ")";
// only support valid convention
oshape[N] = dshape[N];
oshape[C] = dshape[C];
if (param.global_pool) {
oshape[H] = 1;
oshape[W] = 1;
} else {
oshape[H] = 1 + (dshape[H] + 2 * param.pad[0] - param.kernel[0]) /
param.stride[0];
oshape[W] = 1 + (dshape[W] + 2 * param.pad[1] - param.kernel[1]) /
param.stride[1];
}
SHAPE_ASSIGN_CHECK(*in_shape, 1, TShape{1});
SHAPE_ASSIGN_CHECK(*in_shape, 2, TShape{1});
out_shape->clear();
out_shape->push_back(oshape);
out_shape->push_back(TShape{1});
out_shape->push_back(TShape{1});
return true;
}
bool QuantizedPoolingType(const nnvm::NodeAttrs& attrs,
std::vector<int> *in_type,
std::vector<int> *out_type) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK_EQ(in_type->size(), 3U);
CHECK_EQ(out_type->size(), 3U);
if (param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling) {
TYPE_ASSIGN_CHECK(*in_type, 0, mshadow::kInt8);
TYPE_ASSIGN_CHECK(*out_type, 0, mshadow::kInt8);
} else {
LOG(FATAL) << "QuantizedPoolingOp only supports pool_type=max/avg for now";
}
TYPE_ASSIGN_CHECK(*in_type, 1, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*in_type, 2, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*out_type, 1, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*out_type, 2, mshadow::kFloat32);
return true;
}
NNVM_REGISTER_OP(_contrib_quantized_pooling)
.set_num_inputs(3)
.set_num_outputs(3)
.set_attr_parser(ParamParser<PoolingParam>)
.set_attr<nnvm::FListInputNames>("FListInputNames",
[](const NodeAttrs& attrs) {
return std::vector<std::string>{"data", "min_data", "max_data"};
})
.set_attr<nnvm::FListOutputNames>("FListOutputNames",
[](const NodeAttrs& attrs) {
return std::vector<std::string>{"output", "min_output", "max_output"};
})
.set_attr<nnvm::FInferShape>("FInferShape", QuantizedPoolingShape)
.set_attr<nnvm::FInferType>("FInferType", QuantizedPoolingType)
.set_attr<FNeedRequantize>("FNeedRequantize",
[](const NodeAttrs& attrs) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK(param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling)
<< "QuantizedPoolingOp only supports pool_type=max/avg for now";
return false;
})
.add_argument("data", "NDArray-or-Symbol", "Input data.")
.add_argument("min_data", "NDArray-or-Symbol", "Minimum value of data.")
.add_argument("max_data", "NDArray-or-Symbol", "Maximum value of data.")
.add_arguments(PoolingParam::__FIELDS__());
NNVM_REGISTER_OP(Pooling)
.describe(R"code(Pooling operator for input and output data type of int8.
The input and output data comes with min and max thresholds for quantizing
the float32 data into int8.
.. Note::
This operator only supports forward propogation. DO NOT use it in training.
This operator only supports `pool_type` of `avg` or `max`.)code" ADD_FILELINE)
.set_attr<FQuantizedOp>("FQuantizedOp", [](const NodeAttrs& attrs) {
PoolingParam param;
param.Init(attrs.dict);
// TODO(junwu): Uncomment the following line and remove the above lines
// after pooling op is refactored
// const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
nnvm::NodePtr node = nnvm::Node::Create();
if (param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling) {
node->attrs.op = Op::Get("_contrib_quantized_pooling");
node->attrs.name = "quantized_" + attrs.name;
} else {
node->attrs.op = Op::Get("Pooling");
node->attrs.name = attrs.name;
}
node->attrs.dict = attrs.dict;
if (node->op()->attr_parser != nullptr) {
node->op()->attr_parser(&(node->attrs));
}
return node;
});
} // namespace op
} // namespace mxnet
<commit_msg>Fix quantized pooling doc (#10841)<commit_after>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/*!
* Copyright (c) 2017 by Contributors
* \file quantized_pooling.cc
*/
#include <mxnet/op_attr_types.h>
#include "../nn/pooling-inl.h"
namespace mxnet {
namespace op {
bool QuantizedPoolingShape(const nnvm::NodeAttrs& attrs,
std::vector<TShape> *in_shape,
std::vector<TShape> *out_shape) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK_EQ(in_shape->size(), 3U);
if (shape_is_none(in_shape->at(0))) return false;
const TShape &dshape = (*in_shape)[0];
CHECK_EQ(dshape.ndim(), 4U)
<< "quantized_pooling: Input data should be 4D in "
<< "(batch, channel, y, x)";
// NCHW layout
const int N = 0, H = 2, W = 3, C = 1;
TShape oshape(4);
CHECK_EQ(param.kernel.ndim(), 2) << "QuantizedPoolingOp only supports 2D pooling for now";
CHECK(param.kernel[0] <= dshape[H] + 2 * param.pad[0])
<< "kernel size (" << param.kernel[0]
<< ") exceeds input (" << dshape[H]
<< " padded to " << (dshape[H] + 2*param.pad[0]) << ")";
CHECK(param.kernel[1] <= dshape[W] + 2 * param.pad[1])
<< "kernel size (" << param.kernel[1]
<< ") exceeds input (" << dshape[W]
<< " padded to " << (dshape[W] + 2*param.pad[1]) << ")";
// only support valid convention
oshape[N] = dshape[N];
oshape[C] = dshape[C];
if (param.global_pool) {
oshape[H] = 1;
oshape[W] = 1;
} else {
oshape[H] = 1 + (dshape[H] + 2 * param.pad[0] - param.kernel[0]) /
param.stride[0];
oshape[W] = 1 + (dshape[W] + 2 * param.pad[1] - param.kernel[1]) /
param.stride[1];
}
SHAPE_ASSIGN_CHECK(*in_shape, 1, TShape{1});
SHAPE_ASSIGN_CHECK(*in_shape, 2, TShape{1});
out_shape->clear();
out_shape->push_back(oshape);
out_shape->push_back(TShape{1});
out_shape->push_back(TShape{1});
return true;
}
bool QuantizedPoolingType(const nnvm::NodeAttrs& attrs,
std::vector<int> *in_type,
std::vector<int> *out_type) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK_EQ(in_type->size(), 3U);
CHECK_EQ(out_type->size(), 3U);
if (param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling) {
TYPE_ASSIGN_CHECK(*in_type, 0, mshadow::kInt8);
TYPE_ASSIGN_CHECK(*out_type, 0, mshadow::kInt8);
} else {
LOG(FATAL) << "QuantizedPoolingOp only supports pool_type=max/avg for now";
}
TYPE_ASSIGN_CHECK(*in_type, 1, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*in_type, 2, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*out_type, 1, mshadow::kFloat32);
TYPE_ASSIGN_CHECK(*out_type, 2, mshadow::kFloat32);
return true;
}
NNVM_REGISTER_OP(_contrib_quantized_pooling)
.describe(R"code(Pooling operator for input and output data type of int8.
The input and output data comes with min and max thresholds for quantizing
the float32 data into int8.
.. Note::
This operator only supports forward propogation. DO NOT use it in training.
This operator only supports `pool_type` of `avg` or `max`.)code" ADD_FILELINE)
.set_num_inputs(3)
.set_num_outputs(3)
.set_attr_parser(ParamParser<PoolingParam>)
.set_attr<nnvm::FListInputNames>("FListInputNames",
[](const NodeAttrs& attrs) {
return std::vector<std::string>{"data", "min_data", "max_data"};
})
.set_attr<nnvm::FListOutputNames>("FListOutputNames",
[](const NodeAttrs& attrs) {
return std::vector<std::string>{"output", "min_output", "max_output"};
})
.set_attr<nnvm::FInferShape>("FInferShape", QuantizedPoolingShape)
.set_attr<nnvm::FInferType>("FInferType", QuantizedPoolingType)
.set_attr<FNeedRequantize>("FNeedRequantize",
[](const NodeAttrs& attrs) {
const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
CHECK(param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling)
<< "QuantizedPoolingOp only supports pool_type=max/avg for now";
return false;
})
.add_argument("data", "NDArray-or-Symbol", "Input data.")
.add_argument("min_data", "NDArray-or-Symbol", "Minimum value of data.")
.add_argument("max_data", "NDArray-or-Symbol", "Maximum value of data.")
.add_arguments(PoolingParam::__FIELDS__());
NNVM_REGISTER_OP(Pooling)
.set_attr<FQuantizedOp>("FQuantizedOp", [](const NodeAttrs& attrs) {
PoolingParam param;
param.Init(attrs.dict);
// TODO(junwu): Uncomment the following line and remove the above lines
// after pooling op is refactored
// const PoolingParam& param = nnvm::get<PoolingParam>(attrs.parsed);
nnvm::NodePtr node = nnvm::Node::Create();
if (param.pool_type == pool_enum::kMaxPooling || param.pool_type == pool_enum::kAvgPooling) {
node->attrs.op = Op::Get("_contrib_quantized_pooling");
node->attrs.name = "quantized_" + attrs.name;
} else {
node->attrs.op = Op::Get("Pooling");
node->attrs.name = attrs.name;
}
node->attrs.dict = attrs.dict;
if (node->op()->attr_parser != nullptr) {
node->op()->attr_parser(&(node->attrs));
}
return node;
});
} // namespace op
} // namespace mxnet
<|endoftext|> |
<commit_before>//===- BuildSystemTaskTests.cpp -------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "MockBuildSystemDelegate.h"
#include "TempDir.h"
#include "llbuild/Basic/LLVM.h"
#include "llbuild/BuildSystem/BuildDescription.h"
#include "llbuild/BuildSystem/BuildFile.h"
#include "llbuild/BuildSystem/BuildKey.h"
#include "llbuild/BuildSystem/BuildValue.h"
#include "llbuild/BuildSystem/BuildSystem.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include <thread>
#include "gtest/gtest.h"
using namespace llvm;
using namespace llbuild;
using namespace llbuild::buildsystem;
using namespace llbuild::unittests;
namespace {
/// Check that we evaluate a path key properly.
TEST(BuildSystemTaskTests, basics) {
TmpDir tempDir{ __FUNCTION__ };
// Create a sample file.
SmallString<256> path{ tempDir.str() };
sys::path::append(path, "a.txt");
auto testString = StringRef("Hello, world!\n");
{
std::error_code ec;
llvm::raw_fd_ostream os(path, ec, llvm::sys::fs::F_None);
assert(!ec);
os << testString;
}
// Create the build system.
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build a specific key.
auto result = system.build(BuildKey::makeNode(path));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result.getValue().isExistingInput());
ASSERT_EQ(result.getValue().getOutputInfo().size, testString.size());
}
/// Check the evaluation of directory contents.
TEST(BuildSystemTaskTests, directoryContents) {
TmpDir tempDir{ __FUNCTION__ };
// Create a directory with sample files.
SmallString<256> fileA{ tempDir.str() };
sys::path::append(fileA, "fileA");
SmallString<256> fileB{ tempDir.str() };
sys::path::append(fileB, "fileB");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileA";
}
{
std::error_code ec;
llvm::raw_fd_ostream os(fileB, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileB";
}
// Create the build system.
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build a specific key.
{
auto result = system.build(BuildKey::makeDirectoryContents(tempDir.str()));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result->isDirectoryContents());
ASSERT_EQ(result->getDirectoryContents(), std::vector<StringRef>({
StringRef("fileA"), StringRef("fileB") }));
}
// Check that a missing directory behaves properly.
{
auto result = system.build(BuildKey::makeDirectoryContents(
tempDir.str() + "/missing-subpath"));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result->isMissingInput());
}
}
/// Check the evaluation of directory signatures.
TEST(BuildSystemTaskTests, directorySignature) {
TmpDir tempDir{ __FUNCTION__ };
// Create a directory with sample files.
SmallString<256> fileA{ tempDir.str() };
sys::path::append(fileA, "fileA");
SmallString<256> fileB{ tempDir.str() };
sys::path::append(fileB, "fileB");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileA";
}
{
std::error_code ec;
llvm::raw_fd_ostream os(fileB, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileB";
}
SmallString<256> subdirA{ tempDir.str() };
sys::path::append(subdirA, "subdirA");
(void) llvm::sys::fs::create_directories(subdirA.str());
SmallString<256> subdirFileA{ subdirA };
sys::path::append(subdirFileA, "subdirFileA");
{
std::error_code ec;
llvm::raw_fd_ostream os(subdirFileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "subdirFileA";
}
// Create the build system.
auto keyToBuild = BuildKey::makeDirectoryTreeSignature(tempDir.str());
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build an initial value.
auto resultA = system.build(keyToBuild);
ASSERT_TRUE(resultA.hasValue() && resultA->isDirectoryTreeSignature());
// Modify the immediate directory and rebuild.
SmallString<256> fileC{ tempDir.str() };
sys::path::append(fileC, "fileC");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileC, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileC";
}
auto resultB = system.build(keyToBuild);
ASSERT_TRUE(resultB.hasValue() && resultB->isDirectoryTreeSignature());
ASSERT_TRUE(resultA->toData() != resultB->toData());
// Modify the subdirectory and rebuild.
SmallString<256> subdirFileD{ subdirA };
sys::path::append(subdirFileD, "fileD");
{
std::error_code ec;
llvm::raw_fd_ostream os(subdirFileD, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileD";
}
auto resultC = system.build(keyToBuild);
ASSERT_TRUE(resultC.hasValue() && resultC->isDirectoryTreeSignature());
ASSERT_TRUE(resultA->toData() != resultB->toData());
ASSERT_TRUE(resultA->toData() != resultC->toData());
}
TEST(BuildSystemTaskTests, doesNotProcessDependenciesAfterCancellation) {
TmpDir tempDir{ __FUNCTION__ };
std::string outputFile = tempDir.str() + "/output.txt";
SmallString<256> manifest{ tempDir.str() };
sys::path::append(manifest, "manifest.llbuild");
{
std::error_code ec;
llvm::raw_fd_ostream os(manifest, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "client:\n"
" name: mock\n"
"\n"
"commands:\n"
" WAIT:\n"
" tool: shell\n"
" deps: \"/tmp/deps.info\"\n"
" deps-style: dependency-info\n"
" inputs: [\"<cleanup>\"]\n";
os << " outputs: [\"" << outputFile << "\"]\n";
os << " description: \"WAIT\"\n"
" args:\n";
os << " touch " << outputFile << "\n";
os << " sleep 9999\n";
}
auto keyToBuild = BuildKey::makeCommand("WAIT");
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
bool loadingResult = system.loadDescription(manifest);
ASSERT_TRUE(loadingResult);
std::unique_ptr<llbuild::basic::FileSystem> fs = llbuild::basic::createLocalFileSystem();
std::thread cancelThread([&] {
// Busy wait until `outputFile` appears which indicates that `yes` is
// running.
time_t start = ::time(NULL);
while (fs->getFileInfo(outputFile).isMissing()) {
if (::time(NULL) > start + 5) {
// We can't fail gracefully because the `LaneBasedExecutionQueue` will
// always wait for spawned processes to exit
abort();
}
}
system.cancel();
});
auto result = system.build(keyToBuild);
cancelThread.join();
// This is what we are testing for, if dependencies were processed, an error would occur during the build
ASSERT_EQ(delegate.getMessages().size(), 0);
}
}
<commit_msg>[BuildSystem] Fix a compiler warning.<commit_after>//===- BuildSystemTaskTests.cpp -------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "MockBuildSystemDelegate.h"
#include "TempDir.h"
#include "llbuild/Basic/LLVM.h"
#include "llbuild/BuildSystem/BuildDescription.h"
#include "llbuild/BuildSystem/BuildFile.h"
#include "llbuild/BuildSystem/BuildKey.h"
#include "llbuild/BuildSystem/BuildValue.h"
#include "llbuild/BuildSystem/BuildSystem.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include <thread>
#include "gtest/gtest.h"
using namespace llvm;
using namespace llbuild;
using namespace llbuild::buildsystem;
using namespace llbuild::unittests;
namespace {
/// Check that we evaluate a path key properly.
TEST(BuildSystemTaskTests, basics) {
TmpDir tempDir{ __FUNCTION__ };
// Create a sample file.
SmallString<256> path{ tempDir.str() };
sys::path::append(path, "a.txt");
auto testString = StringRef("Hello, world!\n");
{
std::error_code ec;
llvm::raw_fd_ostream os(path, ec, llvm::sys::fs::F_None);
assert(!ec);
os << testString;
}
// Create the build system.
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build a specific key.
auto result = system.build(BuildKey::makeNode(path));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result.getValue().isExistingInput());
ASSERT_EQ(result.getValue().getOutputInfo().size, testString.size());
}
/// Check the evaluation of directory contents.
TEST(BuildSystemTaskTests, directoryContents) {
TmpDir tempDir{ __FUNCTION__ };
// Create a directory with sample files.
SmallString<256> fileA{ tempDir.str() };
sys::path::append(fileA, "fileA");
SmallString<256> fileB{ tempDir.str() };
sys::path::append(fileB, "fileB");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileA";
}
{
std::error_code ec;
llvm::raw_fd_ostream os(fileB, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileB";
}
// Create the build system.
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build a specific key.
{
auto result = system.build(BuildKey::makeDirectoryContents(tempDir.str()));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result->isDirectoryContents());
ASSERT_EQ(result->getDirectoryContents(), std::vector<StringRef>({
StringRef("fileA"), StringRef("fileB") }));
}
// Check that a missing directory behaves properly.
{
auto result = system.build(BuildKey::makeDirectoryContents(
tempDir.str() + "/missing-subpath"));
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result->isMissingInput());
}
}
/// Check the evaluation of directory signatures.
TEST(BuildSystemTaskTests, directorySignature) {
TmpDir tempDir{ __FUNCTION__ };
// Create a directory with sample files.
SmallString<256> fileA{ tempDir.str() };
sys::path::append(fileA, "fileA");
SmallString<256> fileB{ tempDir.str() };
sys::path::append(fileB, "fileB");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileA";
}
{
std::error_code ec;
llvm::raw_fd_ostream os(fileB, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileB";
}
SmallString<256> subdirA{ tempDir.str() };
sys::path::append(subdirA, "subdirA");
(void) llvm::sys::fs::create_directories(subdirA.str());
SmallString<256> subdirFileA{ subdirA };
sys::path::append(subdirFileA, "subdirFileA");
{
std::error_code ec;
llvm::raw_fd_ostream os(subdirFileA, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "subdirFileA";
}
// Create the build system.
auto keyToBuild = BuildKey::makeDirectoryTreeSignature(tempDir.str());
auto description = llvm::make_unique<BuildDescription>();
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
system.loadDescription(std::move(description));
// Build an initial value.
auto resultA = system.build(keyToBuild);
ASSERT_TRUE(resultA.hasValue() && resultA->isDirectoryTreeSignature());
// Modify the immediate directory and rebuild.
SmallString<256> fileC{ tempDir.str() };
sys::path::append(fileC, "fileC");
{
std::error_code ec;
llvm::raw_fd_ostream os(fileC, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileC";
}
auto resultB = system.build(keyToBuild);
ASSERT_TRUE(resultB.hasValue() && resultB->isDirectoryTreeSignature());
ASSERT_TRUE(resultA->toData() != resultB->toData());
// Modify the subdirectory and rebuild.
SmallString<256> subdirFileD{ subdirA };
sys::path::append(subdirFileD, "fileD");
{
std::error_code ec;
llvm::raw_fd_ostream os(subdirFileD, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "fileD";
}
auto resultC = system.build(keyToBuild);
ASSERT_TRUE(resultC.hasValue() && resultC->isDirectoryTreeSignature());
ASSERT_TRUE(resultA->toData() != resultB->toData());
ASSERT_TRUE(resultA->toData() != resultC->toData());
}
TEST(BuildSystemTaskTests, doesNotProcessDependenciesAfterCancellation) {
TmpDir tempDir{ __FUNCTION__ };
std::string outputFile = tempDir.str() + "/output.txt";
SmallString<256> manifest{ tempDir.str() };
sys::path::append(manifest, "manifest.llbuild");
{
std::error_code ec;
llvm::raw_fd_ostream os(manifest, ec, llvm::sys::fs::F_Text);
assert(!ec);
os << "client:\n"
" name: mock\n"
"\n"
"commands:\n"
" WAIT:\n"
" tool: shell\n"
" deps: \"/tmp/deps.info\"\n"
" deps-style: dependency-info\n"
" inputs: [\"<cleanup>\"]\n";
os << " outputs: [\"" << outputFile << "\"]\n";
os << " description: \"WAIT\"\n"
" args:\n";
os << " touch " << outputFile << "\n";
os << " sleep 9999\n";
}
auto keyToBuild = BuildKey::makeCommand("WAIT");
MockBuildSystemDelegate delegate;
BuildSystem system(delegate);
bool loadingResult = system.loadDescription(manifest);
ASSERT_TRUE(loadingResult);
std::unique_ptr<llbuild::basic::FileSystem> fs = llbuild::basic::createLocalFileSystem();
std::thread cancelThread([&] {
// Busy wait until `outputFile` appears which indicates that `yes` is
// running.
time_t start = ::time(NULL);
while (fs->getFileInfo(outputFile).isMissing()) {
if (::time(NULL) > start + 5) {
// We can't fail gracefully because the `LaneBasedExecutionQueue` will
// always wait for spawned processes to exit
abort();
}
}
system.cancel();
});
auto result = system.build(keyToBuild);
cancelThread.join();
// This is what we are testing for, if dependencies were processed, an error would occur during the build
ASSERT_EQ(delegate.getMessages().size(), 0U);
}
}
<|endoftext|> |
<commit_before>/*=========================================================================
Program: Visualization Toolkit
Module: vtkExtractUnstructuredGridPiece.cxx
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkExtractUnstructuredGridPiece.h"
#include "vtkCell.h"
#include "vtkCellArray.h"
#include "vtkCellData.h"
#include "vtkGenericCell.h"
#include "vtkIdList.h"
#include "vtkIntArray.h"
#include "vtkObjectFactory.h"
#include "vtkPointData.h"
#include "vtkUnsignedCharArray.h"
#include "vtkUnstructuredGrid.h"
vtkCxxRevisionMacro(vtkExtractUnstructuredGridPiece, "1.12");
vtkStandardNewMacro(vtkExtractUnstructuredGridPiece);
vtkExtractUnstructuredGridPiece::vtkExtractUnstructuredGridPiece()
{
this->CreateGhostCells = 1;
}
void vtkExtractUnstructuredGridPiece::ComputeInputUpdateExtents(vtkDataObject *out)
{
vtkUnstructuredGrid *input = this->GetInput();
if (this->GetInput() == NULL)
{
vtkErrorMacro("Missing input");
return;
}
out = out;
input->SetUpdateExtent(0, 1, 0);
}
void vtkExtractUnstructuredGridPiece::ExecuteInformation()
{
if (this->GetInput() == NULL)
{
vtkErrorMacro("Missing input");
return;
}
this->GetOutput()->SetMaximumNumberOfPieces(-1);
}
void vtkExtractUnstructuredGridPiece::ComputeCellTags(vtkIntArray *tags,
vtkIdList *pointOwnership,
int piece, int numPieces)
{
vtkUnstructuredGrid *input;
int j;
vtkIdType idx, numCells, ptId;
vtkIdType* cellPointer;
vtkIdType* ids;
vtkIdType numCellPts;
input = this->GetInput();
numCells = input->GetNumberOfCells();
// Clear Point ownership. This is only necessary if we
// Are creating ghost points.
if (pointOwnership)
{
for (idx = 0; idx < input->GetNumberOfPoints(); ++idx)
{
pointOwnership->SetId(idx, -1);
}
}
// Brute force division.
cellPointer = input->GetCells()->GetPointer();
for (idx = 0; idx < numCells; ++idx)
{
if ((idx * numPieces / numCells) == piece)
{
tags->SetValue(idx, 0);
}
else
{
tags->SetValue(idx, -1);
}
// Fill in point ownership mapping.
if (pointOwnership)
{
numCellPts = cellPointer[0];
ids = cellPointer+1;
// Move to the next cell.
cellPointer += (1 + numCellPts);
for (j = 0; j < numCellPts; ++j)
{
ptId = ids[j];
if (pointOwnership->GetId(ptId) == -1)
{
pointOwnership->SetId(ptId, idx);
}
}
}
}
}
void vtkExtractUnstructuredGridPiece::Execute()
{
vtkUnstructuredGrid *input = this->GetInput();
vtkUnstructuredGrid *output = this->GetOutput();
vtkPointData *pd=input->GetPointData(), *outPD=output->GetPointData();
vtkCellData *cd=input->GetCellData(), *outCD=output->GetCellData();
unsigned char* cellTypes = input->GetCellTypesArray()->GetPointer(0);
int cellType;
vtkIntArray *cellTags;
int ghostLevel, piece, numPieces;
vtkIdType cellId, newCellId;
vtkIdList *pointMap;
vtkIdList *newCellPts = vtkIdList::New();
vtkPoints *newPoints;
vtkUnsignedCharArray* cellGhostLevels = 0;
vtkIdList *pointOwnership = 0;
vtkUnsignedCharArray* pointGhostLevels = 0;
vtkIdType i, ptId, newId, numPts, numCells;
int numCellPts;
vtkIdType *cellPointer;
vtkIdType *ids;
float *x;
// Pipeline update piece will tell us what to generate.
ghostLevel = output->GetUpdateGhostLevel();
piece = output->GetUpdatePiece();
numPieces = output->GetUpdateNumberOfPieces();
outPD->CopyAllocate(pd);
outCD->CopyAllocate(cd);
numPts = input->GetNumberOfPoints();
numCells = input->GetNumberOfCells();
if (ghostLevel > 0 && this->CreateGhostCells)
{
cellGhostLevels = vtkUnsignedCharArray::New();
cellGhostLevels->SetNumberOfTuples(numCells);
// We may want to create point ghost levels even
// if there are no ghost cells. Since it cost extra,
// and no filter really uses it, and the filter did not
// create a point ghost level array for this case before,
// I will leave it the way it was.
pointOwnership = vtkIdList::New();
pointOwnership->Allocate(numPts);
pointGhostLevels = vtkUnsignedCharArray::New();
pointGhostLevels->SetNumberOfTuples(numPts);
}
// Break up cells based on which piece they belong to.
cellTags = vtkIntArray::New();
cellTags->Allocate(input->GetNumberOfCells(), 1000);
// Cell tags end up being 0 for cells in piece and -1 for all others.
// Point ownership is the cell that owns the point.
this->ComputeCellTags(cellTags, pointOwnership, piece, numPieces);
// Find the layers of ghost cells.
if (this->CreateGhostCells)
{
for (i = 0; i < ghostLevel; i++)
{
this->AddGhostLevel(input, cellTags, i+1);
}
}
// Filter the cells.
output->Allocate(input->GetNumberOfCells());
newPoints = vtkPoints::New();
newPoints->Allocate(numPts);
pointMap = vtkIdList::New(); //maps old point ids into new
pointMap->SetNumberOfIds(numPts);
for (i=0; i < numPts; i++)
{
pointMap->SetId(i,-1);
}
// Filter the cells
cellPointer = input->GetCells()->GetPointer();
for (cellId=0; cellId < numCells; cellId++)
{
// Direct access to cells.
cellType = cellTypes[cellId];
numCellPts = cellPointer[0];
ids = cellPointer+1;
// Move to the next cell.
cellPointer += (1 + *cellPointer);
if ( cellTags->GetValue(cellId) != -1) // satisfied thresholding
{
if (cellGhostLevels)
{
cellGhostLevels->InsertNextValue(
(unsigned char)(cellTags->GetValue(cellId)));
}
for (i=0; i < numCellPts; i++)
{
ptId = ids[i];
if ( (newId = pointMap->GetId(ptId)) < 0 )
{
x = input->GetPoint(ptId);
newId = newPoints->InsertNextPoint(x);
if (pointGhostLevels && pointOwnership)
{
pointGhostLevels->InsertNextValue(
cellTags->GetValue(pointOwnership->GetId(ptId)));
}
pointMap->SetId(ptId,newId);
outPD->CopyData(pd,ptId,newId);
}
newCellPts->InsertId(i,newId);
}
newCellId = output->InsertNextCell(cellType,newCellPts);
outCD->CopyData(cd,cellId,newCellId);
newCellPts->Reset();
} // satisfied thresholding
} // for all cells
vtkDebugMacro(<< "Extracted " << output->GetNumberOfCells()
<< " number of cells.");
// now clean up / update ourselves
pointMap->Delete();
newCellPts->Delete();
if (cellGhostLevels)
{
cellGhostLevels->SetName("vtkGhostLevels");
output->GetCellData()->AddArray(cellGhostLevels);
cellGhostLevels->Delete();
cellGhostLevels = 0;
}
if (pointGhostLevels)
{
pointGhostLevels->SetName("vtkGhostLevels");
output->GetPointData()->AddArray(pointGhostLevels);
pointGhostLevels->Delete();
pointGhostLevels = 0;
}
output->SetPoints(newPoints);
newPoints->Delete();
output->Squeeze();
cellTags->Delete();
if (pointOwnership)
{
pointOwnership->Delete();
pointOwnership = 0;
}
}
void vtkExtractUnstructuredGridPiece::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
os << indent << "Create Ghost Cells: " << (this->CreateGhostCells ? "On\n" : "Off\n");
}
// This method is still slow...
void vtkExtractUnstructuredGridPiece::AddGhostLevel(vtkUnstructuredGrid *input,
vtkIntArray *cellTags,
int level)
{
vtkIdType numCells, pointId, cellId, i;
int j, k;
vtkGenericCell *cell1 = vtkGenericCell::New();
vtkGenericCell *cell2 = vtkGenericCell::New();
vtkIdList *cellIds = vtkIdList::New();
numCells = input->GetNumberOfCells();
for (i = 0; i < numCells; i++)
{
if (cellTags->GetValue(i) == level - 1)
{
input->GetCell(i, cell1);
for (j = 0; j < cell1->GetNumberOfPoints(); j++)
{
pointId = cell1->GetPointId(j);
input->GetPointCells(pointId, cellIds);
for (k = 0; k < cellIds->GetNumberOfIds(); k++)
{
cellId = cellIds->GetId(k);
if (cellTags->GetValue(cellId) == -1)
{
input->GetCell(cellId, cell2);
cellTags->SetValue(cellId, level);
}
}
}
}
}
cell1->Delete();
cell2->Delete();
cellIds->Delete();
}
<commit_msg>This should fix the UnstructuredGridPieces test.<commit_after>/*=========================================================================
Program: Visualization Toolkit
Module: vtkExtractUnstructuredGridPiece.cxx
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkExtractUnstructuredGridPiece.h"
#include "vtkCell.h"
#include "vtkCellArray.h"
#include "vtkCellData.h"
#include "vtkGenericCell.h"
#include "vtkIdList.h"
#include "vtkIntArray.h"
#include "vtkObjectFactory.h"
#include "vtkPointData.h"
#include "vtkUnsignedCharArray.h"
#include "vtkUnstructuredGrid.h"
vtkCxxRevisionMacro(vtkExtractUnstructuredGridPiece, "1.13");
vtkStandardNewMacro(vtkExtractUnstructuredGridPiece);
vtkExtractUnstructuredGridPiece::vtkExtractUnstructuredGridPiece()
{
this->CreateGhostCells = 1;
}
void vtkExtractUnstructuredGridPiece::ComputeInputUpdateExtents(vtkDataObject *out)
{
vtkUnstructuredGrid *input = this->GetInput();
if (this->GetInput() == NULL)
{
vtkErrorMacro("Missing input");
return;
}
out = out;
input->SetUpdateExtent(0, 1, 0);
}
void vtkExtractUnstructuredGridPiece::ExecuteInformation()
{
if (this->GetInput() == NULL)
{
vtkErrorMacro("Missing input");
return;
}
this->GetOutput()->SetMaximumNumberOfPieces(-1);
}
void vtkExtractUnstructuredGridPiece::ComputeCellTags(vtkIntArray *tags,
vtkIdList *pointOwnership,
int piece, int numPieces)
{
vtkUnstructuredGrid *input;
int j;
vtkIdType idx, numCells, ptId;
vtkIdType* cellPointer;
vtkIdType* ids;
vtkIdType numCellPts;
input = this->GetInput();
numCells = input->GetNumberOfCells();
// Clear Point ownership. This is only necessary if we
// Are creating ghost points.
if (pointOwnership)
{
for (idx = 0; idx < input->GetNumberOfPoints(); ++idx)
{
pointOwnership->SetId(idx, -1);
}
}
// Brute force division.
cellPointer = input->GetCells()->GetPointer();
for (idx = 0; idx < numCells; ++idx)
{
if ((idx * numPieces / numCells) == piece)
{
tags->SetValue(idx, 0);
}
else
{
tags->SetValue(idx, -1);
}
// Fill in point ownership mapping.
if (pointOwnership)
{
numCellPts = cellPointer[0];
ids = cellPointer+1;
// Move to the next cell.
cellPointer += (1 + numCellPts);
for (j = 0; j < numCellPts; ++j)
{
ptId = ids[j];
if (pointOwnership->GetId(ptId) == -1)
{
pointOwnership->SetId(ptId, idx);
}
}
}
}
}
void vtkExtractUnstructuredGridPiece::Execute()
{
vtkUnstructuredGrid *input = this->GetInput();
vtkUnstructuredGrid *output = this->GetOutput();
vtkPointData *pd=input->GetPointData(), *outPD=output->GetPointData();
vtkCellData *cd=input->GetCellData(), *outCD=output->GetCellData();
unsigned char* cellTypes = input->GetCellTypesArray()->GetPointer(0);
int cellType;
vtkIntArray *cellTags;
int ghostLevel, piece, numPieces;
vtkIdType cellId, newCellId;
vtkIdList *pointMap;
vtkIdList *newCellPts = vtkIdList::New();
vtkPoints *newPoints;
vtkUnsignedCharArray* cellGhostLevels = 0;
vtkIdList *pointOwnership = 0;
vtkUnsignedCharArray* pointGhostLevels = 0;
vtkIdType i, ptId, newId, numPts, numCells;
int numCellPts;
vtkIdType *cellPointer;
vtkIdType *ids;
float *x;
// Pipeline update piece will tell us what to generate.
ghostLevel = output->GetUpdateGhostLevel();
piece = output->GetUpdatePiece();
numPieces = output->GetUpdateNumberOfPieces();
outPD->CopyAllocate(pd);
outCD->CopyAllocate(cd);
numPts = input->GetNumberOfPoints();
numCells = input->GetNumberOfCells();
if (ghostLevel > 0 && this->CreateGhostCells)
{
cellGhostLevels = vtkUnsignedCharArray::New();
cellGhostLevels->Allocate(numCells);
// We may want to create point ghost levels even
// if there are no ghost cells. Since it cost extra,
// and no filter really uses it, and the filter did not
// create a point ghost level array for this case before,
// I will leave it the way it was.
pointOwnership = vtkIdList::New();
pointOwnership->Allocate(numPts);
pointGhostLevels = vtkUnsignedCharArray::New();
pointGhostLevels->Allocate(numPts);
}
// Break up cells based on which piece they belong to.
cellTags = vtkIntArray::New();
cellTags->Allocate(input->GetNumberOfCells(), 1000);
// Cell tags end up being 0 for cells in piece and -1 for all others.
// Point ownership is the cell that owns the point.
this->ComputeCellTags(cellTags, pointOwnership, piece, numPieces);
// Find the layers of ghost cells.
if (this->CreateGhostCells)
{
for (i = 0; i < ghostLevel; i++)
{
this->AddGhostLevel(input, cellTags, i+1);
}
}
// Filter the cells.
output->Allocate(input->GetNumberOfCells());
newPoints = vtkPoints::New();
newPoints->Allocate(numPts);
pointMap = vtkIdList::New(); //maps old point ids into new
pointMap->SetNumberOfIds(numPts);
for (i=0; i < numPts; i++)
{
pointMap->SetId(i,-1);
}
// Filter the cells
cellPointer = input->GetCells()->GetPointer();
for (cellId=0; cellId < numCells; cellId++)
{
// Direct access to cells.
cellType = cellTypes[cellId];
numCellPts = cellPointer[0];
ids = cellPointer+1;
// Move to the next cell.
cellPointer += (1 + *cellPointer);
if ( cellTags->GetValue(cellId) != -1) // satisfied thresholding
{
if (cellGhostLevels)
{
cellGhostLevels->InsertNextValue(
(unsigned char)(cellTags->GetValue(cellId)));
}
for (i=0; i < numCellPts; i++)
{
ptId = ids[i];
if ( (newId = pointMap->GetId(ptId)) < 0 )
{
x = input->GetPoint(ptId);
newId = newPoints->InsertNextPoint(x);
if (pointGhostLevels && pointOwnership)
{
pointGhostLevels->InsertNextValue(
cellTags->GetValue(pointOwnership->GetId(ptId)));
}
pointMap->SetId(ptId,newId);
outPD->CopyData(pd,ptId,newId);
}
newCellPts->InsertId(i,newId);
}
newCellId = output->InsertNextCell(cellType,newCellPts);
outCD->CopyData(cd,cellId,newCellId);
newCellPts->Reset();
} // satisfied thresholding
} // for all cells
vtkDebugMacro(<< "Extracted " << output->GetNumberOfCells()
<< " number of cells.");
// now clean up / update ourselves
pointMap->Delete();
newCellPts->Delete();
if (cellGhostLevels)
{
cellGhostLevels->SetName("vtkGhostLevels");
output->GetCellData()->AddArray(cellGhostLevels);
cellGhostLevels->Delete();
cellGhostLevels = 0;
}
if (pointGhostLevels)
{
pointGhostLevels->SetName("vtkGhostLevels");
output->GetPointData()->AddArray(pointGhostLevels);
pointGhostLevels->Delete();
pointGhostLevels = 0;
}
output->SetPoints(newPoints);
newPoints->Delete();
output->Squeeze();
cellTags->Delete();
if (pointOwnership)
{
pointOwnership->Delete();
pointOwnership = 0;
}
}
void vtkExtractUnstructuredGridPiece::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os,indent);
os << indent << "Create Ghost Cells: " << (this->CreateGhostCells ? "On\n" : "Off\n");
}
// This method is still slow...
void vtkExtractUnstructuredGridPiece::AddGhostLevel(vtkUnstructuredGrid *input,
vtkIntArray *cellTags,
int level)
{
vtkIdType numCells, pointId, cellId, i;
int j, k;
vtkGenericCell *cell1 = vtkGenericCell::New();
vtkGenericCell *cell2 = vtkGenericCell::New();
vtkIdList *cellIds = vtkIdList::New();
numCells = input->GetNumberOfCells();
for (i = 0; i < numCells; i++)
{
if (cellTags->GetValue(i) == level - 1)
{
input->GetCell(i, cell1);
for (j = 0; j < cell1->GetNumberOfPoints(); j++)
{
pointId = cell1->GetPointId(j);
input->GetPointCells(pointId, cellIds);
for (k = 0; k < cellIds->GetNumberOfIds(); k++)
{
cellId = cellIds->GetId(k);
if (cellTags->GetValue(cellId) == -1)
{
input->GetCell(cellId, cell2);
cellTags->SetValue(cellId, level);
}
}
}
}
}
cell1->Delete();
cell2->Delete();
cellIds->Delete();
}
<|endoftext|> |
<commit_before>/*
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/external/gtest.h>
#include <aws/core/auth/AWSCredentialsProviderChain.h>
#include <aws/core/utils/memory/AWSMemory.h>
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateSecurityGroupRequest.h>
#include <aws/ec2/model/CreateSecurityGroupResponse.h>
#include <aws/ec2/model/CreateVpcRequest.h>
#include <aws/ec2/model/CreateVpcResponse.h>
#include <aws/ec2/model/DeleteSecurityGroupRequest.h>
#include <aws/ec2/model/DeleteVpcRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsResponse.h>
#include <aws/ec2/model/DescribeSpotFleetRequestsRequest.h>
#include <aws/ec2/model/DescribeSpotFleetRequestsResponse.h>
#include <aws/ec2/model/DescribeVpcsRequest.h>
#include <aws/ec2/model/DescribeVpcsResponse.h>
#include <chrono>
#include <thread>
using namespace Aws::Auth;
using namespace Aws::Http;
using namespace Aws::Client;
namespace
{
static const char* ALLOCATION_TAG = "EC2Tests";
static const char* SECURITY_GROUP_NAME = "CppSDKIntegrationTestSecurityGroup";
class EC2OperationTest : public ::testing::Test
{
protected:
enum class ObjectState {
Ready,
Nonexistent
};
std::shared_ptr<Aws::EC2::EC2Client> m_EC2Client;
Aws::String m_vpcId;
virtual void SetUp()
{
ClientConfiguration config;
config.scheme = Scheme::HTTPS;
config.region = Aws::Region::US_EAST_1;
m_EC2Client = Aws::MakeShared<Aws::EC2::EC2Client>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG), config);
Aws::EC2::Model::CreateVpcRequest createVpcRequest;
createVpcRequest.SetCidrBlock("0.0.0.0/0");
createVpcRequest.SetInstanceTenancy(Aws::EC2::Model::Tenancy::default_);
auto createOutcome = m_EC2Client->CreateVpc(createVpcRequest);
ASSERT_TRUE(createOutcome.IsSuccess());
m_vpcId = createOutcome.GetResult().GetVpc().GetVpcId();
DeleteSecurityGroup(SECURITY_GROUP_NAME);
}
virtual void TearDown()
{
DeleteSecurityGroup(SECURITY_GROUP_NAME);
DeleteVpc(m_vpcId);
m_EC2Client = nullptr;
}
void DeleteSecurityGroup(const Aws::String& groupName)
{
Aws::EC2::Model::DeleteSecurityGroupRequest deleteRequest;
deleteRequest.SetGroupName(groupName);
m_EC2Client->DeleteSecurityGroup(deleteRequest);
WaitOnSecurityGroupState(groupName, ObjectState::Nonexistent);
}
void WaitOnSecurityGroupState(const Aws::String& groupName, ObjectState objectState)
{
Aws::EC2::Model::DescribeSecurityGroupsRequest describeRequest;
describeRequest.AddGroupNames(groupName);
bool finished = false;
while(!finished)
{
auto describeOutcome = m_EC2Client->DescribeSecurityGroups(describeRequest);
if (describeOutcome.IsSuccess())
{
const Aws::Vector< Aws::EC2::Model::SecurityGroup >& groups = describeOutcome.GetResult().GetSecurityGroups();
bool exists = std::find_if(groups.cbegin(), groups.cend(), [](const Aws::EC2::Model::SecurityGroup& group){ return group.GetGroupName() == SECURITY_GROUP_NAME; }) != groups.cend();
finished = (objectState == ObjectState::Nonexistent && !exists) || (objectState == ObjectState::Ready && exists);
}
if (!finished)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
}
void DeleteVpc(const Aws::String vpcId)
{
Aws::EC2::Model::DeleteVpcRequest deleteVpcRequest;
deleteVpcRequest.SetVpcId(vpcId);
auto deleteOutcome = m_EC2Client->DeleteVpc(deleteVpcRequest);
ASSERT_TRUE(deleteOutcome.IsSuccess());
WaitOnVpcState(vpcId, ObjectState::Nonexistent);
}
void WaitOnVpcState(const Aws::String& vpcId, ObjectState objectState)
{
Aws::EC2::Model::DescribeVpcsRequest describeRequest;
describeRequest.AddVpcIds(vpcId);
bool finished = false;
while(!finished)
{
auto describeOutcome = m_EC2Client->DescribeVpcs(describeRequest);
if (describeOutcome.IsSuccess())
{
const Aws::Vector< Aws::EC2::Model::Vpc >& vpcs = describeOutcome.GetResult().GetVpcs();
bool exists = std::find_if(vpcs.cbegin(), vpcs.cend(), [vpcId](const Aws::EC2::Model::Vpc& vpc){ return vpc.GetVpcId() == vpcId; }) != vpcs.cend();
finished = (objectState == ObjectState::Nonexistent && !exists) || (objectState == ObjectState::Ready && exists);
}
if (!finished)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
}
};
} // anonymous namespace
TEST_F(EC2OperationTest, DescribeSpotFleet)
{
Aws::EC2::Model::DescribeSpotFleetRequestsRequest request;
auto outcome = m_EC2Client->DescribeSpotFleetRequests(request);
ASSERT_TRUE(outcome.IsSuccess());
}
TEST_F(EC2OperationTest, CreateSecurityGroup)
{
Aws::EC2::Model::CreateSecurityGroupRequest createRequest;
createRequest.SetGroupName(SECURITY_GROUP_NAME);
createRequest.SetDescription("A dummy description");
auto createOutcome = m_EC2Client->CreateSecurityGroup(createRequest);
ASSERT_TRUE(createOutcome.IsSuccess());
}
<commit_msg>Test updates<commit_after>/*
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/external/gtest.h>
#include <aws/core/auth/AWSCredentialsProviderChain.h>
#include <aws/core/utils/memory/AWSMemory.h>
#include <aws/ec2/EC2Client.h>
#include <aws/ec2/model/CreateSecurityGroupRequest.h>
#include <aws/ec2/model/CreateSecurityGroupResponse.h>
#include <aws/ec2/model/CreateVpcRequest.h>
#include <aws/ec2/model/CreateVpcResponse.h>
#include <aws/ec2/model/DeleteSecurityGroupRequest.h>
#include <aws/ec2/model/DeleteVpcRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsRequest.h>
#include <aws/ec2/model/DescribeSecurityGroupsResponse.h>
#include <aws/ec2/model/DescribeSpotFleetRequestsRequest.h>
#include <aws/ec2/model/DescribeSpotFleetRequestsResponse.h>
#include <aws/ec2/model/DescribeVpcsRequest.h>
#include <aws/ec2/model/DescribeVpcsResponse.h>
#include <chrono>
#include <thread>
using namespace Aws::Auth;
using namespace Aws::Http;
using namespace Aws::Client;
namespace
{
static const char* ALLOCATION_TAG = "EC2Tests";
static const char* SECURITY_GROUP_NAME = "CppSDKIntegrationTestSecurityGroup";
class EC2OperationTest : public ::testing::Test
{
protected:
enum class ObjectState {
Ready,
Nonexistent
};
std::shared_ptr<Aws::EC2::EC2Client> m_EC2Client;
Aws::String m_vpcId;
virtual void SetUp()
{
ClientConfiguration config;
config.scheme = Scheme::HTTPS;
config.region = Aws::Region::US_EAST_1;
m_EC2Client = Aws::MakeShared<Aws::EC2::EC2Client>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG), config);
Aws::EC2::Model::CreateVpcRequest createVpcRequest;
createVpcRequest.SetCidrBlock("0.0.0.0/0");
createVpcRequest.SetInstanceTenancy(Aws::EC2::Model::Tenancy::default_);
auto createOutcome = m_EC2Client->CreateVpc(createVpcRequest);
ASSERT_TRUE(createOutcome.IsSuccess());
m_vpcId = createOutcome.GetResult().GetVpc().GetVpcId();
WaitOnVpcState(m_vpcId, ObjectState::Ready);
DeleteSecurityGroup(SECURITY_GROUP_NAME);
}
virtual void TearDown()
{
DeleteSecurityGroup(SECURITY_GROUP_NAME);
DeleteVpc(m_vpcId);
m_EC2Client = nullptr;
}
void DeleteSecurityGroup(const Aws::String& groupName)
{
Aws::EC2::Model::DeleteSecurityGroupRequest deleteRequest;
deleteRequest.SetGroupName(groupName);
m_EC2Client->DeleteSecurityGroup(deleteRequest);
WaitOnSecurityGroupState(groupName, ObjectState::Nonexistent);
}
void WaitOnSecurityGroupState(const Aws::String& groupName, ObjectState objectState)
{
Aws::EC2::Model::DescribeSecurityGroupsRequest describeRequest;
describeRequest.AddGroupNames(groupName);
bool finished = false;
while(!finished)
{
auto describeOutcome = m_EC2Client->DescribeSecurityGroups(describeRequest);
if (describeOutcome.IsSuccess())
{
const Aws::Vector< Aws::EC2::Model::SecurityGroup >& groups = describeOutcome.GetResult().GetSecurityGroups();
bool exists = std::find_if(groups.cbegin(), groups.cend(), [](const Aws::EC2::Model::SecurityGroup& group){ return group.GetGroupName() == SECURITY_GROUP_NAME; }) != groups.cend();
finished = (objectState == ObjectState::Nonexistent && !exists) || (objectState == ObjectState::Ready && exists);
}
else if (describeOutcome.GetError().GetErrorType() == Aws::EC2::EC2Errors::INVALID_GROUP__NOT_FOUND)
{
finished = objectState == ObjectState::Nonexistent;
}
if (!finished)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
}
void DeleteVpc(const Aws::String vpcId)
{
Aws::EC2::Model::DeleteVpcRequest deleteVpcRequest;
deleteVpcRequest.SetVpcId(vpcId);
auto deleteOutcome = m_EC2Client->DeleteVpc(deleteVpcRequest);
ASSERT_TRUE(deleteOutcome.IsSuccess());
WaitOnVpcState(vpcId, ObjectState::Nonexistent);
}
void WaitOnVpcState(const Aws::String& vpcId, ObjectState objectState)
{
Aws::EC2::Model::DescribeVpcsRequest describeRequest;
describeRequest.AddVpcIds(vpcId);
bool finished = false;
while(!finished)
{
auto describeOutcome = m_EC2Client->DescribeVpcs(describeRequest);
if (describeOutcome.IsSuccess())
{
const Aws::Vector< Aws::EC2::Model::Vpc >& vpcs = describeOutcome.GetResult().GetVpcs();
bool exists = std::find_if(vpcs.cbegin(), vpcs.cend(), [vpcId](const Aws::EC2::Model::Vpc& vpc){ return vpc.GetVpcId() == vpcId; }) != vpcs.cend();
finished = (objectState == ObjectState::Nonexistent && !exists) || (objectState == ObjectState::Ready && exists);
}
else if (describeOutcome.GetError().GetErrorType() == Aws::EC2::EC2Errors::INVALID_VPC_I_D__NOT_FOUND)
{
finished = objectState == ObjectState::Nonexistent;
}
if (!finished)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
}
};
} // anonymous namespace
TEST_F(EC2OperationTest, DescribeSpotFleet)
{
Aws::EC2::Model::DescribeSpotFleetRequestsRequest request;
auto outcome = m_EC2Client->DescribeSpotFleetRequests(request);
ASSERT_TRUE(outcome.IsSuccess());
}
TEST_F(EC2OperationTest, CreateSecurityGroup)
{
Aws::EC2::Model::CreateSecurityGroupRequest createRequest;
createRequest.SetGroupName(SECURITY_GROUP_NAME);
createRequest.SetDescription("A dummy description");
auto createOutcome = m_EC2Client->CreateSecurityGroup(createRequest);
ASSERT_TRUE(createOutcome.IsSuccess());
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2012, The Cinder Project, All rights reserved.
Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
This code is intended for use with the Cinder C++ library: http://libcinder.org
Redistribution and use in source and binary forms, with or without modification, are permitted provided that
the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#define ASIO_STANDALONE 1
#include "asio/asio.hpp"
#include "cinder/app/App.h"
#include "cinder/app/Renderer.h"
#include "cinder/Camera.h"
#include "cinder/System.h"
#include "cinder/Utilities.h"
#include "cinder/Timeline.h"
#include "cinder/Thread.h"
#include "cinder/Log.h"
#if defined( CINDER_COCOA )
#if defined( CINDER_MAC )
#import "cinder/app/CinderView.h"
#import <Cocoa/Cocoa.h>
#endif
#include "cinder/cocoa/CinderCocoa.h"
#elif defined( CINDER_WINRT )
#include "cinder/app/AppImplWinRT.h"
#include <thread>
#include <filesystem>
#elif defined( CINDER_MSW )
#include "cinder/app/AppImplMsw.h"
#endif
using namespace std;
namespace cinder { namespace app {
#if defined( CINDER_COCOA )
void* App::sAutoReleasePool = 0;
#endif
// Static instance of App, effectively a singleton
App* App::sInstance;
static std::thread::id sPrimaryThreadId = std::this_thread::get_id();
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// App::Settings
App::Settings::Settings()
{
mShouldQuit = false;
mPowerManagement = false;
mFrameRateEnabled = true;
mFrameRate = 60.0f;
mEnableHighDensityDisplay = false;
mEnableMultiTouch = false;
}
void App::Settings::disableFrameRate()
{
mFrameRateEnabled = false;
}
void App::Settings::setFrameRate( float frameRate )
{
mFrameRate = frameRate;
}
void App::Settings::enablePowerManagement( bool powerManagement )
{
mPowerManagement = powerManagement;
}
void App::Settings::prepareWindow( const Window::Format &format )
{
mWindowFormats.push_back( format );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// App::App
App::App()
: mFrameCount( 0 ), mAverageFps( 0 ), mFpsSampleInterval( 1 ), mTimer( true ), mTimeline( Timeline::create() )
{
mFpsLastSampleFrame = 0;
mFpsLastSampleTime = 0;
mIo = shared_ptr<asio::io_service>( new asio::io_service() );
mIoWork = shared_ptr<asio::io_service::work>( new asio::io_service::work( *mIo ) );
// due to an issue with boost::filesystem's static initialization on Windows,
// it's necessary to create a fs::path here in case of secondary threads doing the same thing simultaneously
#if (defined( CINDER_MSW ) || defined ( CINDER_WINRT ))
fs::path dummyPath( "dummy" );
#endif
}
App::~App()
{
mIo->stop();
}
void App::privateSetup__()
{
mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) );
setup();
}
void App::privateUpdate__()
{
mFrameCount++;
<<<<<<< HEAD
#if !defined( CINDER_WINRT )
// service asio::io_service
=======
>>>>>>> removed #if guards for boost::asio::io_service on WinRT, it should be possible to support now.
mIo->poll();
if( getNumWindows() > 0 ) {
WindowRef mainWin = getWindowIndex( 0 );
if( mainWin )
mainWin->getRenderer()->makeCurrentContext();
}
mSignalUpdate();
update();
mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) );
double now = mTimer.getSeconds();
if( now > mFpsLastSampleTime + mFpsSampleInterval ) {
//calculate average Fps over sample interval
uint32_t framesPassed = mFrameCount - mFpsLastSampleFrame;
mAverageFps = (float)(framesPassed / (now - mFpsLastSampleTime));
mFpsLastSampleTime = now;
mFpsLastSampleFrame = mFrameCount;
}
}
void App::emitShutdown()
{
mSignalShutdown();
shutdown();
}
void App::emitWillResignActive()
{
mSignalWillResignActive();
}
void App::emitDidBecomeActive()
{
mSignalDidBecomeActive();
}
std::ostream& App::console()
{
return Platform::get()->console();
}
bool App::isPrimaryThread()
{
return std::this_thread::get_id() == sPrimaryThreadId;
}
void App::dispatchAsync( const std::function<void()> &fn )
{
io_service().post( fn );
}
Surface App::copyWindowSurface()
{
return getWindow()->getRenderer()->copyWindowSurface( getWindow()->toPixels( getWindow()->getBounds() ) );
}
Surface App::copyWindowSurface( const Area &area )
{
Area clippedArea = area.getClipBy( getWindowBounds() );
return getWindow()->getRenderer()->copyWindowSurface( clippedArea );
}
RendererRef App::findSharedRenderer( RendererRef searchRenderer ) const
{
if( ! searchRenderer )
return RendererRef();
for( size_t winIdx = 0; winIdx < getNumWindows(); ++winIdx ) {
RendererRef thisRenderer = getWindowIndex( winIdx )->getRenderer();
if( thisRenderer && (typeid( *thisRenderer ) == typeid(*searchRenderer)) )
return getWindowIndex( winIdx )->getRenderer();
}
return RendererRef(); // didn't find one
}
// These are called by application instantiation macros
void App::prepareLaunch()
{
#if defined( CINDER_COCOA )
sAutoReleasePool = [[NSAutoreleasePool alloc] init];
#endif
}
void App::executeLaunch( App *app, RendererRef defaultRenderer, const char *title, int argc, char * const argv[] )
{
sInstance = app;
app->mDefaultRenderer = defaultRenderer;
try {
app->launch( title, argc, argv );
}
catch( std::exception &exc ) {
CI_LOG_E( "Uncaught exception, type: " << ci::System::demangleTypeName( typeid( exc ).name() ) << ", what : " << exc.what() );
throw;
}
}
void App::cleanupLaunch()
{
#if defined( CINDER_COCOA )
sAutoReleasePool = [[NSAutoreleasePool alloc] init];
#endif
}
} } // namespace cinder::app<commit_msg>remove no long needed platform specific includes<commit_after>/*
Copyright (c) 2012, The Cinder Project, All rights reserved.
Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
This code is intended for use with the Cinder C++ library: http://libcinder.org
Redistribution and use in source and binary forms, with or without modification, are permitted provided that
the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#define ASIO_STANDALONE 1
#include "asio/asio.hpp"
#include "cinder/app/App.h"
#include "cinder/app/Renderer.h"
#include "cinder/Camera.h"
#include "cinder/System.h"
#include "cinder/Utilities.h"
#include "cinder/Timeline.h"
#include "cinder/Thread.h"
#include "cinder/Log.h"
using namespace std;
namespace cinder { namespace app {
#if defined( CINDER_COCOA )
void* App::sAutoReleasePool = 0;
#endif
// Static instance of App, effectively a singleton
App* App::sInstance;
static std::thread::id sPrimaryThreadId = std::this_thread::get_id();
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// App::Settings
App::Settings::Settings()
{
mShouldQuit = false;
mPowerManagement = false;
mFrameRateEnabled = true;
mFrameRate = 60.0f;
mEnableHighDensityDisplay = false;
mEnableMultiTouch = false;
}
void App::Settings::disableFrameRate()
{
mFrameRateEnabled = false;
}
void App::Settings::setFrameRate( float frameRate )
{
mFrameRate = frameRate;
}
void App::Settings::enablePowerManagement( bool powerManagement )
{
mPowerManagement = powerManagement;
}
void App::Settings::prepareWindow( const Window::Format &format )
{
mWindowFormats.push_back( format );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// App::App
App::App()
: mFrameCount( 0 ), mAverageFps( 0 ), mFpsSampleInterval( 1 ), mTimer( true ), mTimeline( Timeline::create() )
{
mFpsLastSampleFrame = 0;
mFpsLastSampleTime = 0;
mIo = shared_ptr<asio::io_service>( new asio::io_service() );
mIoWork = shared_ptr<asio::io_service::work>( new asio::io_service::work( *mIo ) );
// due to an issue with boost::filesystem's static initialization on Windows,
// it's necessary to create a fs::path here in case of secondary threads doing the same thing simultaneously
#if (defined( CINDER_MSW ) || defined ( CINDER_WINRT ))
fs::path dummyPath( "dummy" );
#endif
}
App::~App()
{
mIo->stop();
}
void App::privateSetup__()
{
mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) );
setup();
}
void App::privateUpdate__()
{
mFrameCount++;
<<<<<<< HEAD
#if !defined( CINDER_WINRT )
// service asio::io_service
=======
>>>>>>> removed #if guards for boost::asio::io_service on WinRT, it should be possible to support now.
mIo->poll();
if( getNumWindows() > 0 ) {
WindowRef mainWin = getWindowIndex( 0 );
if( mainWin )
mainWin->getRenderer()->makeCurrentContext();
}
mSignalUpdate();
update();
mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) );
double now = mTimer.getSeconds();
if( now > mFpsLastSampleTime + mFpsSampleInterval ) {
//calculate average Fps over sample interval
uint32_t framesPassed = mFrameCount - mFpsLastSampleFrame;
mAverageFps = (float)(framesPassed / (now - mFpsLastSampleTime));
mFpsLastSampleTime = now;
mFpsLastSampleFrame = mFrameCount;
}
}
void App::emitShutdown()
{
mSignalShutdown();
shutdown();
}
void App::emitWillResignActive()
{
mSignalWillResignActive();
}
void App::emitDidBecomeActive()
{
mSignalDidBecomeActive();
}
std::ostream& App::console()
{
return Platform::get()->console();
}
bool App::isPrimaryThread()
{
return std::this_thread::get_id() == sPrimaryThreadId;
}
void App::dispatchAsync( const std::function<void()> &fn )
{
io_service().post( fn );
}
Surface App::copyWindowSurface()
{
return getWindow()->getRenderer()->copyWindowSurface( getWindow()->toPixels( getWindow()->getBounds() ) );
}
Surface App::copyWindowSurface( const Area &area )
{
Area clippedArea = area.getClipBy( getWindowBounds() );
return getWindow()->getRenderer()->copyWindowSurface( clippedArea );
}
RendererRef App::findSharedRenderer( RendererRef searchRenderer ) const
{
if( ! searchRenderer )
return RendererRef();
for( size_t winIdx = 0; winIdx < getNumWindows(); ++winIdx ) {
RendererRef thisRenderer = getWindowIndex( winIdx )->getRenderer();
if( thisRenderer && (typeid( *thisRenderer ) == typeid(*searchRenderer)) )
return getWindowIndex( winIdx )->getRenderer();
}
return RendererRef(); // didn't find one
}
// These are called by application instantiation macros
void App::prepareLaunch()
{
#if defined( CINDER_COCOA )
sAutoReleasePool = [[NSAutoreleasePool alloc] init];
#endif
}
void App::executeLaunch( App *app, RendererRef defaultRenderer, const char *title, int argc, char * const argv[] )
{
sInstance = app;
app->mDefaultRenderer = defaultRenderer;
try {
app->launch( title, argc, argv );
}
catch( std::exception &exc ) {
CI_LOG_E( "Uncaught exception, type: " << ci::System::demangleTypeName( typeid( exc ).name() ) << ", what : " << exc.what() );
throw;
}
}
void App::cleanupLaunch()
{
#if defined( CINDER_COCOA )
sAutoReleasePool = [[NSAutoreleasePool alloc] init];
#endif
}
} } // namespace cinder::app<|endoftext|> |
<commit_before>/*
* Copyright 2017, Andrej Kislovskij
*
* This is PUBLIC DOMAIN software so use at your own risk as it comes
* with no warranties. This code is yours to share, use and modify without
* any restrictions or obligations.
*
* For more information see conwrap/LICENSE or refer refer to http://unlicense.org
*
* Author: gimesketvirtadieni at gmail dot com (Andrej Kislovskij)
*/
#pragma once
#include <cstddef> // std::size_t
#include <FLAC++/encoder.h>
#include <string>
#include "slim/log/log.hpp"
#include "slim/util/AsyncWriter.hpp"
#include "slim/util/BufferedAsyncWriter.hpp"
namespace slim
{
namespace flac
{
class Encoder : protected FLAC::Encoder::Stream
{
public:
explicit Encoder(unsigned int c, unsigned int s, unsigned int bs, unsigned int bv, std::reference_wrapper<util::AsyncWriter> w, bool h)
: channels{c}
, sampleRate{s}
, bitsPerSample{bs}
, bitsPerValue{bv}
, bufferedWriter{w}
{
// do not validate FLAC encoded stream if it produces the same result
if (!set_verify(false))
{
throw Exception("Could not disable FLAC stream verification");
}
// setting maximum possible compression level
if (set_compression_level(8))
{
throw Exception("Could not set compression level");
}
// setting amount of channels
if (set_channels(channels))
{
throw Exception("Could not set amount of channels");
}
// setting sampling rate
if (set_sample_rate(sampleRate))
{
throw Exception("Could not set sampling rate");
}
// FLAC encoding support max 24 bits per value
auto b{bitsPerValue};
if (b > 24)
{
LOG(WARNING) << LABELS{"flac"} << "PCM data will be scaled to 24 bits values, which is max bit depth supported by FLAC";
b = 24;
downScale = true;
}
// setting sampling rate
if (set_bits_per_sample(b))
{
throw Exception("Could not set bits per sample");
}
// choosing big enough number of expected samples for streaming purpose
if (set_total_samples_estimate(0xFFFFFFFF))
{
throw Exception("Could not set estimated amount of samples");
}
// initializing FLAC encoder
auto init_status{init()};
if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
{
throw Exception(FLAC__StreamEncoderInitStatusString[init_status]);
}
}
~Encoder()
{
if (!finish())
{
LOG(ERROR) << LABELS{"flac"} << "Error while closing encoder: " << get_state().as_cstring();
}
}
Encoder(const Encoder&) = delete; // non-copyable
Encoder& operator=(const Encoder&) = delete; // non-assignable
Encoder(Encoder&&) = delete; // non-movable
Encoder& operator=(Encoder&&) = delete; // non-assign-movable
auto encode(unsigned char* data, const std::size_t size)
{
std::size_t encoded{0};
// do not feed encoder with more data if there is no room in transfer buffer
if (bufferedWriter.isBufferAvailable())
{
std::size_t bytesPerSample{bitsPerSample >> 3};
std::size_t samples{size / bytesPerSample};
std::size_t frames{samples / channels};
// if values contain more than 24 bits then downscaling to 24 bits, which is max supported by FLAC
if (downScale)
{
for (std::size_t i = 0; i < size; i += bytesPerSample)
{
data[i] = 0;
}
}
// TODO: generialize based on parameters (bitsPerFrame and bitsPerValue)
// coverting data S32_LE to S24_LE by shifting data by 1 byte
if (frames > 1 && !process_interleaved((const FLAC__int32*)(data + 1), frames - 1))
{
LOG(ERROR) << LABELS{"flac"} << get_state().as_cstring();
}
// handling the last frame separately; requred due to data shift
if (frames > 0)
{
unsigned char lastFrame[8] =
{
data[size - 7],
data[size - 6],
data[size - 5],
0,
data[size - 3],
data[size - 2],
data[size - 1],
0
};
if (!process_interleaved((const FLAC__int32*)lastFrame, 1))
{
LOG(ERROR) << LABELS{"flac"} << get_state().as_cstring();
}
}
// notifing the caller about amount of data processed
encoded = size;
}
else
{
LOG(WARNING) << LABELS{"flac"} << "Transfer buffer is full - skipping PCM chunk";
}
return encoded;
}
auto getMIME()
{
return std::string{"audio/flac"};
}
protected:
virtual ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte* data, std::size_t size, unsigned samples, unsigned current_frame) override
{
bufferedWriter.writeAsync(data, size, [](auto error, auto written)
{
if (error)
{
LOG(ERROR) << LABELS{"flac"} << "Error while encoded data transfer: " << error.message();
}
});
return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
}
private:
unsigned int channels;
unsigned int sampleRate;
unsigned int bitsPerSample;
unsigned int bitsPerValue;
bool downScale{false};
// TODO: parametrize
util::BufferedAsyncWriter<10> bufferedWriter;
};
}
}
<commit_msg>Refactoring FLAC streamer<commit_after>/*
* Copyright 2017, Andrej Kislovskij
*
* This is PUBLIC DOMAIN software so use at your own risk as it comes
* with no warranties. This code is yours to share, use and modify without
* any restrictions or obligations.
*
* For more information see conwrap/LICENSE or refer refer to http://unlicense.org
*
* Author: gimesketvirtadieni at gmail dot com (Andrej Kislovskij)
*/
#pragma once
#include <cstddef> // std::size_t
#include <FLAC++/encoder.h>
#include <string>
#include "slim/log/log.hpp"
#include "slim/util/AsyncWriter.hpp"
#include "slim/util/BufferedAsyncWriter.hpp"
namespace slim
{
namespace flac
{
class Encoder : protected FLAC::Encoder::Stream
{
public:
explicit Encoder(unsigned int c, unsigned int s, unsigned int bs, unsigned int bv, std::reference_wrapper<util::AsyncWriter> w, bool h)
: channels{c}
, sampleRate{s}
, bitsPerSample{bs}
, bitsPerValue{bv}
, bufferedWriter{w}
{
// do not validate FLAC encoded stream if it produces the same result
if (!set_verify(false))
{
throw Exception("Could not disable FLAC stream verification");
}
// setting maximum possible compression level
if (!set_compression_level(8))
{
throw Exception("Could not set compression level");
}
// setting amount of channels
if (!set_channels(channels))
{
throw Exception("Could not set amount of channels");
}
// setting sampling rate
if (!set_sample_rate(sampleRate))
{
throw Exception("Could not set sampling rate");
}
// FLAC encoding support max 24 bits per value
auto b{bitsPerValue};
if (b > 24)
{
LOG(WARNING) << LABELS{"flac"} << "PCM data will be scaled to 24 bits values, which is max bit depth supported by FLAC";
b = 24;
downScale = true;
}
// setting sampling rate
if (!set_bits_per_sample(b))
{
throw Exception("Could not set bits per sample");
}
// choosing big enough number of expected samples for streaming purpose
if (!set_total_samples_estimate(0xFFFFFFFF))
{
throw Exception("Could not set estimated amount of samples");
}
// initializing FLAC encoder
auto init_status{init()};
if (init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
{
throw Exception(FLAC__StreamEncoderInitStatusString[init_status]);
}
}
~Encoder()
{
if (!finish())
{
LOG(ERROR) << LABELS{"flac"} << "Error while closing encoder: " << get_state().as_cstring();
}
}
Encoder(const Encoder&) = delete; // non-copyable
Encoder& operator=(const Encoder&) = delete; // non-assignable
Encoder(Encoder&&) = delete; // non-movable
Encoder& operator=(Encoder&&) = delete; // non-assign-movable
auto encode(unsigned char* data, const std::size_t size)
{
std::size_t encoded{0};
// do not feed encoder with more data if there is no room in transfer buffer
if (bufferedWriter.isBufferAvailable())
{
std::size_t bytesPerSample{bitsPerSample >> 3};
std::size_t samples{size / bytesPerSample};
std::size_t frames{samples / channels};
// if values contain more than 24 bits then downscaling to 24 bits, which is max supported by FLAC
if (downScale)
{
for (std::size_t i = 0; i < size; i += bytesPerSample)
{
data[i] = 0;
}
}
// TODO: generialize based on parameters (bitsPerFrame and bitsPerValue)
// coverting data S32_LE to S24_LE by shifting data by 1 byte
if (frames > 1 && !process_interleaved((const FLAC__int32*)(data + 1), frames - 1))
{
LOG(ERROR) << LABELS{"flac"} << get_state().as_cstring();
}
// handling the last frame separately; requred due to data shift
if (frames > 0)
{
unsigned char lastFrame[8] =
{
data[size - 7],
data[size - 6],
data[size - 5],
0,
data[size - 3],
data[size - 2],
data[size - 1],
0
};
if (!process_interleaved((const FLAC__int32*)lastFrame, 1))
{
LOG(ERROR) << LABELS{"flac"} << get_state().as_cstring();
}
}
// notifing the caller about amount of data processed
encoded = size;
}
else
{
LOG(WARNING) << LABELS{"flac"} << "Transfer buffer is full - skipping PCM chunk";
}
return encoded;
}
auto getMIME()
{
return std::string{"audio/flac"};
}
protected:
virtual ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte* data, std::size_t size, unsigned samples, unsigned current_frame) override
{
bufferedWriter.writeAsync(data, size, [](auto error, auto written)
{
if (error)
{
LOG(ERROR) << LABELS{"flac"} << "Error while encoded data transfer: " << error.message();
}
});
return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
}
private:
unsigned int channels;
unsigned int sampleRate;
unsigned int bitsPerSample;
unsigned int bitsPerValue;
bool downScale{false};
// TODO: parametrize
util::BufferedAsyncWriter<10> bufferedWriter;
};
}
}
<|endoftext|> |
<commit_before>#include "app.hpp"
#include "solver.hpp"
#include "../build/config.hpp"
#include <cstring>
extern "C" {
#include "unistd.h" // for 'isatty'
};
namespace CaDiCaL {
Solver * App::solver;
void App::usage () {
fputs (
"usage: cadical [ <option> ... ] [ <input> [ <proof> ] ]\n"
"\n"
"where '<option>' is one of the following short options\n"
"\n"
" -h print this command line option summary\n"
" -n do not print witness\n"
" -q quiet (same as '--quiet')\n"
" -v more verbose messages (same as '--verbose')\n"
"\n"
" -c check witness on original formula\n"
" for testing and debuging\n"
"\n"
" -s <sol> read solution in competition output format\n"
" to check consistency of learned clauses\n"
" during testing and debugging\n"
"\n"
"or '<option>' can be one of the following long options\n"
"\n",
stdout);
Options::usage ();
fputs (
"\n"
"The long options have their default value printed in brackets\n"
"after their description. They can also be used in the form\n"
"'--<name>' which is equivalent to '--<name>=1' and in the form\n"
"'--no-<name>' which is equivalent to '--<name>=0'.\n"
"\n"
"Note that decimal integers are casted to 'double' and 'bool'\n"
"in the natural way, e.g., '1' is interpreted as 'true'.\n"
"\n"
"Then '<input>' is a (compressed) DIMACS file and '<output>'\n"
"is a file to store the DRAT proof. If no '<proof>' file is\n"
"specified, then no proof is generated. If no '<input>' is given\n"
"then '<stdin>' is used. If '-' is used as '<input>' then the\n"
"solver reads from '<stdin>'. If '-' is specified for '<proof>'\n"
"then the proof is generated and printed to '<stdout>'.\n",
stdout);
}
void App::check_satisfying_assignment (int (Solver::*assignment)(int)) {
bool satisfied = false;
size_t start = 0;
for (size_t i = 0; i < solver->original.size (); i++) {
int lit = solver->original[i];
if (!lit) {
if (!satisfied) {
fflush (stdout);
fputs ("*** cadical error: unsatisfied clause:\n", stderr);
for (size_t j = start; j < i; j++)
fprintf (stderr, "%d ", solver->original[j]);
fputs ("0\n", stderr);
fflush (stderr);
abort ();
}
satisfied = false;
start = i + 1;
} else if (!satisfied && (solver->*assignment) (lit) > 0) satisfied = true;
}
MSG ("satisfying assignment checked");
}
void App::print_witness () {
int c = 0;
for (int i = 1; i <= solver->max_var; i++) {
if (!c) File::print ('v'), c = 1;
char str[20];
sprintf (str, " %d", solver->val (i) < 0 ? -i : i);
int l = strlen (str);
if (c + l > 78) File::print ("\nv"), c = 1;
File::print (str);
c += l;
}
if (c) File::print ('\n');
File::print ("v 0\n");
fflush (stdout);
}
void App::banner () {
SECTION ("banner");
MSG ("CaDiCaL Radically Simplified CDCL SAT Solver");
MSG ("Version " VERSION " " GITID);
MSG ("Copyright (c) 2016 Armin Biere, JKU");
MSG (COMPILE);
}
bool App::set (const char * arg) { return solver->opts.set (arg); }
int App::main (int argc, char ** argv) {
File * dimacs = 0, * proof = 0, * solution = 0;
bool trace_proof = false, binary_proof = true;
const char * proof_name = 0;
int i, res;
solver = new Solver ();
for (i = 1; i < argc; i++) {
if (!strcmp (argv[i], "-h")) usage (), exit (0);
else if (!strcmp (argv[i], "--version"))
fputs (VERSION "\n", stdout), exit (0);
else if (!strcmp (argv[i], "-")) {
if (trace_proof) DIE ("too many arguments");
else if (!dimacs) dimacs = File::read (stdin, "<stdin>");
else trace_proof = true, proof_name = 0;
} else if (!strcmp (argv[i], "-s")) {
if (++i == argc) DIE ("argument to '-s' missing");
if (solution) DIE ("multiple solution files");
if (!(solution = File::read (argv[i])))
DIE ("can not read solution file '%s'", argv[i]);
} else if (!strcmp (argv[i], "-n")) set ("--no-witness");
else if (!strcmp (argv[i], "-q")) set ("--quiet");
else if (!strcmp (argv[i], "-v")) set ("--verbose");
else if (!strcmp (argv[i], "-c")) set ("--check");
else if (set (argv[i])) { /* nothing do be done */ }
else if (argv[i][0] == '-') DIE ("invalid option '%s'", argv[i]);
else if (trace_proof) DIE ("too many arguments");
else if (dimacs) trace_proof = true, proof_name = argv[i];
else if (!(dimacs = File::read (argv[i])))
DIE ("can not open and read DIMACS file '%s'", argv[i]);
}
if (solution && !solver->opts.check) set ("--check");
if (!dimacs) dimacs = File::read (stdin, "<stdin>");
banner ();
Signal::init (solver);
SECTION ("parsing input");
MSG ("reading DIMACS file from '%s'", dimacs->name ());
Parser dimacs_parser (solver, dimacs);
dimacs_parser.parse_dimacs ();
delete dimacs;
if (solution) {
SECTION ("parsing solution");
Parser solution_parser (solver, solution);
MSG ("reading solution file from '%s'", solution->name ());
solution_parser.parse_solution ();
delete solution;
check_satisfying_assignment (&Solver::sol);
}
solver->opts.print ();
SECTION ("proof tracing");
if (trace_proof) {
if (!proof_name) {
proof = File::write (stdout, "<stdout>");
if (isatty (1) && solver->opts.binary) {
MSG ("forcing non-binary proof: '<stdout>' connected to terminal");
binary_proof = false;
}
} else if (!(proof = File::write (proof_name)))
DIE ("can not open and write DRAT proof to '%s'", proof_name);
if (binary_proof && !solver->opts.binary) binary_proof = false;
MSG ("writing %s DRAT proof trace to '%s'",
(binary_proof ? "binary" : "non-binary"), proof->name ());
solver->proof = new Proof (solver, proof, binary_proof);
} else MSG ("will not generate nor write DRAT proof");
res = solver->solve ();
if (proof) { delete proof; solver->proof = 0; }
SECTION ("result");
if (res == 10) {
check_satisfying_assignment (&Solver::val);
printf ("s SATISFIABLE\n");
if (solver->opts.witness) print_witness ();
fflush (stdout);
} else {
assert (res = 20);
printf ("s UNSATISFIABLE\n");
fflush (stdout);
}
Signal::reset ();
solver->stats.print ();
MSG ("exit %d", res);
if (!solver->opts.leak) delete solver;
solver = 0;
return res;
}
};
<commit_msg>fixed usage<commit_after>#include "app.hpp"
#include "solver.hpp"
#include "../build/config.hpp"
#include <cstring>
extern "C" {
#include "unistd.h" // for 'isatty'
};
namespace CaDiCaL {
Solver * App::solver;
void App::usage () {
fputs (
"usage: cadical [ <option> ... ] [ <input> [ <proof> ] ]\n"
"\n"
"where '<option>' is one of the following short options\n"
"\n"
" -h print this command line option summary\n"
" -n do not print witness\n"
" -q quiet (same as '--quiet')\n"
" -v more verbose messages (same as '--verbose')\n"
"\n"
" -c check witness on original formula\n"
" for testing and debuging\n"
"\n"
" -s <sol> read solution in competition output format\n"
" to check consistency of learned clauses\n"
" during testing and debugging\n"
"\n"
"or '<option>' can be one of the following long options\n"
"\n",
stdout);
Options::usage ();
fputs (
"\n"
"The long options have their default value printed in brackets\n"
"after their description. They can also be used in the form\n"
"'--<name>' which is equivalent to '--<name>=1' and in the form\n"
"'--no-<name>' which is equivalent to '--<name>=0'.\n"
"\n"
"Note that decimal integers are casted to 'double' and 'bool'\n"
"in the natural way, e.g., '1' is interpreted as 'true'.\n"
"\n"
"Then '<input>' has to be a DIMACS file and in '<output>' a DRAT\n"
"proof is saved. If no '<proof>' file is specified, then no proof\n"
"is generated. If no '<input>' is given then '<stdin>' is used.\n"
"If '-' is used as '<input>' then the solver reads from '<stdin>'.\n"
"If '-' is specified for '<proof> then a proof is generated and\n"
"printed to '<stdout>'. The proof is by default stored in binary\n"
"format unless '--binary=0' or the proof is written to '<stdout>'\n"
"and '<stdout>' is connected to a terminal.\n"
"\n"
"The input is assumed to be compressed if it is given explicitly\n"
"and has a '.gz', '.bz2' or '.7z' suffix. The same applies to the\n"
"output file. For decompression helper commands 'gunzip', 'bzcat'\n"
"and '7z' are needed, and for proof compression
"and '7z' have to be in the path and are used through opening a pipe.\n",
stdout);
}
void App::check_satisfying_assignment (int (Solver::*assignment)(int)) {
bool satisfied = false;
size_t start = 0;
for (size_t i = 0; i < solver->original.size (); i++) {
int lit = solver->original[i];
if (!lit) {
if (!satisfied) {
fflush (stdout);
fputs ("*** cadical error: unsatisfied clause:\n", stderr);
for (size_t j = start; j < i; j++)
fprintf (stderr, "%d ", solver->original[j]);
fputs ("0\n", stderr);
fflush (stderr);
abort ();
}
satisfied = false;
start = i + 1;
} else if (!satisfied && (solver->*assignment) (lit) > 0) satisfied = true;
}
MSG ("satisfying assignment checked");
}
void App::print_witness () {
int c = 0;
for (int i = 1; i <= solver->max_var; i++) {
if (!c) File::print ('v'), c = 1;
char str[20];
sprintf (str, " %d", solver->val (i) < 0 ? -i : i);
int l = strlen (str);
if (c + l > 78) File::print ("\nv"), c = 1;
File::print (str);
c += l;
}
if (c) File::print ('\n');
File::print ("v 0\n");
fflush (stdout);
}
void App::banner () {
SECTION ("banner");
MSG ("CaDiCaL Radically Simplified CDCL SAT Solver");
MSG ("Version " VERSION " " GITID);
MSG ("Copyright (c) 2016 Armin Biere, JKU");
MSG (COMPILE);
}
bool App::set (const char * arg) { return solver->opts.set (arg); }
int App::main (int argc, char ** argv) {
File * dimacs = 0, * proof = 0, * solution = 0;
bool trace_proof = false, binary_proof = true;
const char * proof_name = 0;
int i, res;
solver = new Solver ();
for (i = 1; i < argc; i++) {
if (!strcmp (argv[i], "-h")) usage (), exit (0);
else if (!strcmp (argv[i], "--version"))
fputs (VERSION "\n", stdout), exit (0);
else if (!strcmp (argv[i], "-")) {
if (trace_proof) DIE ("too many arguments");
else if (!dimacs) dimacs = File::read (stdin, "<stdin>");
else trace_proof = true, proof_name = 0;
} else if (!strcmp (argv[i], "-s")) {
if (++i == argc) DIE ("argument to '-s' missing");
if (solution) DIE ("multiple solution files");
if (!(solution = File::read (argv[i])))
DIE ("can not read solution file '%s'", argv[i]);
} else if (!strcmp (argv[i], "-n")) set ("--no-witness");
else if (!strcmp (argv[i], "-q")) set ("--quiet");
else if (!strcmp (argv[i], "-v")) set ("--verbose");
else if (!strcmp (argv[i], "-c")) set ("--check");
else if (set (argv[i])) { /* nothing do be done */ }
else if (argv[i][0] == '-') DIE ("invalid option '%s'", argv[i]);
else if (trace_proof) DIE ("too many arguments");
else if (dimacs) trace_proof = true, proof_name = argv[i];
else if (!(dimacs = File::read (argv[i])))
DIE ("can not open and read DIMACS file '%s'", argv[i]);
}
if (solution && !solver->opts.check) set ("--check");
if (!dimacs) dimacs = File::read (stdin, "<stdin>");
banner ();
Signal::init (solver);
SECTION ("parsing input");
MSG ("reading DIMACS file from '%s'", dimacs->name ());
Parser dimacs_parser (solver, dimacs);
dimacs_parser.parse_dimacs ();
delete dimacs;
if (solution) {
SECTION ("parsing solution");
Parser solution_parser (solver, solution);
MSG ("reading solution file from '%s'", solution->name ());
solution_parser.parse_solution ();
delete solution;
check_satisfying_assignment (&Solver::sol);
}
solver->opts.print ();
SECTION ("proof tracing");
if (trace_proof) {
if (!proof_name) {
proof = File::write (stdout, "<stdout>");
if (isatty (1) && solver->opts.binary) {
MSG ("forcing non-binary proof: '<stdout>' connected to terminal");
binary_proof = false;
}
} else if (!(proof = File::write (proof_name)))
DIE ("can not open and write DRAT proof to '%s'", proof_name);
if (binary_proof && !solver->opts.binary) binary_proof = false;
MSG ("writing %s DRAT proof trace to '%s'",
(binary_proof ? "binary" : "non-binary"), proof->name ());
solver->proof = new Proof (solver, proof, binary_proof);
} else MSG ("will not generate nor write DRAT proof");
res = solver->solve ();
if (proof) { delete proof; solver->proof = 0; }
SECTION ("result");
if (res == 10) {
check_satisfying_assignment (&Solver::val);
printf ("s SATISFIABLE\n");
if (solver->opts.witness) print_witness ();
fflush (stdout);
} else {
assert (res = 20);
printf ("s UNSATISFIABLE\n");
fflush (stdout);
}
Signal::reset ();
solver->stats.print ();
MSG ("exit %d", res);
if (!solver->opts.leak) delete solver;
solver = 0;
return res;
}
};
<|endoftext|> |
<commit_before>#include <vector>
#include <string>
#include "util/winpath.hpp"
namespace cygscript {
class App
{
int _argc;
char* const* _argv;
enum class Command { NONE, EXEC, REGISTER, UNREGISTER, LIST };
Command _cmd;
enum class RegisterType { USER, EVERYONE };
RegisterType _regType;
std::string _extension;
std::string _iconPath;
bool _force;
public:
/**
* Constructor.
*
* @param const int argc Argc from main function
* @param char* const argv[] Argv from main function
*/
App(const int argc, char* const argv[]);
/**
* Run application.
*
* @return int Exit code
*/
int run();
/**
* Get Windows path to this application.
*
* @return WinPathW Windows path
*/
static WinPathW getPath();
private:
/**
* Print application usage.
*/
void _printUsage(char* progname);
/**
* Print application version.
*/
void _printVersion();
/**
* Get the command line argumenst in wide strings.
*
* @return std::vector<std::wstring> List of arguments
*/
std::vector<std::wstring> _wideArgs();
/**
* Check whether process is currently running as elevated.
*
* Prompts for elevation if not currently elevated.
*/
void _checkElevated();
};
}
<commit_msg>Add include guard<commit_after>#ifndef __APP_HPP__
#define __APP_HPP__
#include <vector>
#include <string>
#include "util/winpath.hpp"
namespace cygscript {
class App
{
int _argc;
char* const* _argv;
enum class Command { NONE, EXEC, REGISTER, UNREGISTER, LIST };
Command _cmd;
enum class RegisterType { USER, EVERYONE };
RegisterType _regType;
std::string _extension;
std::string _iconPath;
bool _force;
public:
/**
* Constructor.
*
* @param const int argc Argc from main function
* @param char* const argv[] Argv from main function
*/
App(const int argc, char* const argv[]);
/**
* Run application.
*
* @return int Exit code
*/
int run();
/**
* Get Windows path to this application.
*
* @return WinPathW Windows path
*/
static WinPathW getPath();
private:
/**
* Print application usage.
*/
void _printUsage(char* progname);
/**
* Print application version.
*/
void _printVersion();
/**
* Get the command line argumenst in wide strings.
*
* @return std::vector<std::wstring> List of arguments
*/
std::vector<std::wstring> _wideArgs();
/**
* Check whether process is currently running as elevated.
*
* Prompts for elevation if not currently elevated.
*/
void _checkElevated();
};
}
#endif
<|endoftext|> |
<commit_before>#include <tiramisu/debug.h>
#include <tiramisu/core.h>
#include <string.h>
#include <Halide.h>
#include "baryon_wrapper.h"
#include "benchmarks.h"
using namespace tiramisu;
/*
* The goal is to generate code that implements the reference.
* baryon_ref.cpp
*/
void generate_function(std::string name, int size)
{
tiramisu::global::set_default_tiramisu_options();
// -------------------------------------------------------
// Layer I
// -------------------------------------------------------
tiramisu::function function0(name);
global::set_implicit_function(&function0);
tiramisu::constant N_CONST("N", tiramisu::expr((int32_t) size), p_int32, true, NULL, 0, &function0);
tiramisu::constant BT_CONST("BT", tiramisu::expr((int32_t) BT), p_int32, true, NULL, 0, &function0);
tiramisu::constant a1("a1", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant a2("a2", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant a3("a3", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant xp0("xp0", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant KMAX("KMAX", tiramisu::expr((int32_t) BK), p_int32, true, NULL, 0, &function0);
tiramisu::constant b0("b0", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant b1("b1", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::constant b2("b2", tiramisu::expr((int32_t) 0), p_int32, true, NULL, 0, &function0);
tiramisu::var i3("i3"), i2("i2"), i1("i1"), k("k", 1, KMAX), t("t");
tiramisu::input fc1("fc1", {k}, p_int32);
tiramisu::input fc2("fc2", {k}, p_int32);
tiramisu::input fc3("fc3", {k}, p_int32);
tiramisu::computation S("{S[xp0, a1, t, i1, i2, i3, d1]}", tiramisu::expr(), false, p_float32, &function0);
tiramisu::computation wp("{wp[k, b0, b1, b2]}", tiramisu::expr(), false, p_float32, &function0);
tiramisu::computation d1("[BT, N, KMAX]->{d1[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc1(k), true, p_int32, &function0);
tiramisu::computation d2("[BT, N, KMAX]->{d2[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc2(k), true, p_int32, &function0);
tiramisu::computation d3("[BT, N, KMAX]->{d3[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc3(k), true, p_int32, &function0);
tiramisu::computation Res0("[BT, N, KMAX]->{Res0[t, i1, i2, i3, k]: 0<=t<BT and 0<=i1<N and 0<=i2<N and 0<=i3<N and 1<=k<KMAX}", tiramisu::expr(), true, p_float32, &function0);
Res0.set_expression(
S(xp0, a1, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d3(0,0,0,0,0))
+ S(xp0, a1, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d1(0,0,0,0,0))
+ S(xp0, a1, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d2(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d3(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d1(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d2(0,0,0,0,0))
);
tiramisu::computation Res1("[BT, N]->{Res1[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and k=0}", tiramisu::expr((float) 0), true, p_float32, &function0);
tiramisu::computation Res1_update_0("[BT, N, KMAX]->{Res1_update_0[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", tiramisu::expr(), true, p_float32, &function0);
Res1_update_0.set_expression(Res1(t, i1, i2, i3, k-1) + wp(k, b2, b1, b0) * Res0(t, i1, i2, i3, k));
tiramisu::computation Res2("[BT, N]->{Res2[t]: 0<=t<BT}", tiramisu::expr((float) 0), true, p_float32, &function0);
tiramisu::computation Res2_update_0("[BT, N]->{Res2_update_0[t, i1, i2, i3]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N}", tiramisu::expr(), true, p_float32, &function0);
Res2_update_0.set_expression(Res2_update_0(t, i1, i2, i3) + /* exp(i(i3*px+i2*py+i1*pz)) */ Res1(t, i1, i2, i3, 0));
function0.add_context_constraints("[N, M, K,BT]->{:N=16}, BT=16");
// -------------------------------------------------------
// Layer III
// -------------------------------------------------------
tiramisu::buffer buf_fc1("buf_fc1", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_fc2("buf_fc2", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_fc3("buf_fc3", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_res0("buf_res0", {BZ}, tiramisu::p_float32, a_temporary, &function0);
buf_res0.set_auto_allocate(false);
tiramisu::computation *alloc_res0 = buf_res0.allocate_at(Res2, t);
tiramisu::buffer buf_res1("buf_res1", {N_CONST}, tiramisu::p_float32, a_temporary, &function0);
buf_res1.set_auto_allocate(false);
tiramisu::computation *alloc_res1 = buf_res1.allocate_at(Res2, t);
tiramisu::buffer buf_res2("buf_res2", {BT_CONST}, tiramisu::p_float32, a_output, &function0);
tiramisu::buffer buf_d1("buf_d1", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d1.set_auto_allocate(false);
tiramisu::computation *alloc_d1 = buf_d1.allocate_at(Res2, t);
tiramisu::buffer buf_d2("buf_d2", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d2.set_auto_allocate(false);
tiramisu::computation *alloc_d2 = buf_d2.allocate_at(Res2, t);
tiramisu::buffer buf_d3("buf_d3", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d3.set_auto_allocate(false);
tiramisu::computation *alloc_d3 = buf_d3.allocate_at(Res2, t);
// S(d1, i3, i2, i1, t, a1, x’0)
tiramisu::buffer buf_S("buf_S", {tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), N_CONST, N_CONST, N_CONST, tiramisu::expr((int32_t) BARYON_P1)}, tiramisu::p_float32, a_input, &function0);
tiramisu::buffer buf_wp("buf_wp", {tiramisu::expr((int32_t) BARYON_N), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P)}, tiramisu::p_float32, a_input, &function0);
fc1.store_in(&buf_fc1);
fc2.store_in(&buf_fc2);
fc3.store_in(&buf_fc3);
d1.store_in(&buf_d1, {0});
d2.store_in(&buf_d2, {0});
d3.store_in(&buf_d3, {0});
Res0.store_in(&buf_res0, {i3});
Res1.store_in(&buf_res1, {i3});
Res1_update_0.store_in(&buf_res1, {i3});
Res2.store_in(&buf_res2, {t});
Res2_update_0.store_in(&buf_res2, {t});
S.store_in(&buf_S);
wp.store_in(&buf_wp);
// -------------------------------------------------------
// Layer II
// -------------------------------------------------------
Res2.then(*alloc_res1, t)
.then(*alloc_res0, t)
.then(*alloc_d1, t)
.then(*alloc_d2, t)
.then(*alloc_d3, t)
.then(Res1, i3)
.then(d1, i3)
.then(d2, k)
.then(d3, k)
.then(Res0, k)
.then(Res1_update_0, k)
.then(Res2_update_0, i2);
Res0.tag_vector_level(i3, BARYON_N);
Res2.tag_parallel_level(t);
// -------------------------------------------------------
// Code Generation
// -------------------------------------------------------
function0.set_arguments({&buf_res2, &buf_S, &buf_wp, &buf_fc1, &buf_fc2, &buf_fc3});
function0.gen_time_space_domain();
function0.gen_isl_ast();
function0.gen_halide_stmt();
function0.gen_halide_obj("generated_" + std::string(TEST_NAME_STR) + ".o");
}
int main(int argc, char **argv)
{
generate_function("tiramisu_generated_code", BARYON_N);
return 0;
}
<commit_msg>Use new API for Baryon (step 2)<commit_after>#include <tiramisu/debug.h>
#include <tiramisu/core.h>
#include <string.h>
#include <Halide.h>
#include "baryon_wrapper.h"
#include "benchmarks.h"
using namespace tiramisu;
/*
* The goal is to generate code that implements the reference.
* baryon_ref.cpp
*/
void generate_function(std::string name, int size)
{
tiramisu::global::set_default_tiramisu_options();
// -------------------------------------------------------
// Layer I
// -------------------------------------------------------
tiramisu::function function0(name);
global::set_implicit_function(&function0);
tiramisu::constant N_CONST("N", tiramisu::expr((int32_t) size));
tiramisu::constant BT_CONST("BT", tiramisu::expr((int32_t) BT));
tiramisu::constant a1("a1", tiramisu::expr((int32_t) 0));
tiramisu::constant a2("a2", tiramisu::expr((int32_t) 0));
tiramisu::constant a3("a3", tiramisu::expr((int32_t) 0));
tiramisu::constant xp0("xp0", tiramisu::expr((int32_t) 0));
tiramisu::constant KMAX("KMAX", tiramisu::expr((int32_t) BK));
tiramisu::constant b0("b0", tiramisu::expr((int32_t) 0));
tiramisu::constant b1("b1", tiramisu::expr((int32_t) 0));
tiramisu::constant b2("b2", tiramisu::expr((int32_t) 0));
tiramisu::var i3("i3"), i2("i2"), i1("i1"), k("k", 1, KMAX), t("t");
tiramisu::input fc1("fc1", {k}, p_int32);
tiramisu::input fc2("fc2", {k}, p_int32);
tiramisu::input fc3("fc3", {k}, p_int32);
tiramisu::computation S("{S[xp0, a1, t, i1, i2, i3, d1]}", tiramisu::expr(), false, p_float32, &function0);
tiramisu::computation wp("{wp[k, b0, b1, b2]}", tiramisu::expr(), false, p_float32, &function0);
tiramisu::computation d1("[BT, N, KMAX]->{d1[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc1(k), true, p_int32, &function0);
tiramisu::computation d2("[BT, N, KMAX]->{d2[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc2(k), true, p_int32, &function0);
tiramisu::computation d3("[BT, N, KMAX]->{d3[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", fc3(k), true, p_int32, &function0);
tiramisu::computation Res0("[BT, N, KMAX]->{Res0[t, i1, i2, i3, k]: 0<=t<BT and 0<=i1<N and 0<=i2<N and 0<=i3<N and 1<=k<KMAX}", tiramisu::expr(), true, p_float32, &function0);
Res0.set_expression(
S(xp0, a1, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d3(0,0,0,0,0))
+ S(xp0, a1, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d1(0,0,0,0,0))
+ S(xp0, a1, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d2(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d3(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d2(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d1(0,0,0,0,0))
- S(xp0, a1, t, i1, i2, i3, d1(0,0,0,0,0)) * S(xp0, a2, t, i1, i2, i3, d3(0,0,0,0,0)) * S(xp0, a3, t, i1, i2, i3, d2(0,0,0,0,0))
);
tiramisu::computation Res1("[BT, N]->{Res1[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and k=0}", tiramisu::expr((float) 0), true, p_float32, &function0);
tiramisu::computation Res1_update_0("[BT, N, KMAX]->{Res1_update_0[t, i1, i2, i3, k]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N and 1<=k<KMAX}", tiramisu::expr(), true, p_float32, &function0);
Res1_update_0.set_expression(Res1(t, i1, i2, i3, k-1) + wp(k, b2, b1, b0) * Res0(t, i1, i2, i3, k));
tiramisu::computation Res2("[BT, N]->{Res2[t]: 0<=t<BT}", tiramisu::expr((float) 0), true, p_float32, &function0);
tiramisu::computation Res2_update_0("[BT, N]->{Res2_update_0[t, i1, i2, i3]: 0<=t<BT and 0<=i3<N and 0<=i2<N and 0<=i1<N}", tiramisu::expr(), true, p_float32, &function0);
Res2_update_0.set_expression(Res2_update_0(t, i1, i2, i3) + /* exp(i(i3*px+i2*py+i1*pz)) */ Res1(t, i1, i2, i3, 0));
function0.add_context_constraints("[N, M, K,BT]->{:N=16}, BT=16");
// -------------------------------------------------------
// Layer III
// -------------------------------------------------------
tiramisu::buffer buf_fc1("buf_fc1", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_fc2("buf_fc2", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_fc3("buf_fc3", {KMAX}, tiramisu::p_int32, a_input, &function0);
tiramisu::buffer buf_res0("buf_res0", {BZ}, tiramisu::p_float32, a_temporary, &function0);
buf_res0.set_auto_allocate(false);
tiramisu::computation *alloc_res0 = buf_res0.allocate_at(Res2, t);
tiramisu::buffer buf_res1("buf_res1", {N_CONST}, tiramisu::p_float32, a_temporary, &function0);
buf_res1.set_auto_allocate(false);
tiramisu::computation *alloc_res1 = buf_res1.allocate_at(Res2, t);
tiramisu::buffer buf_res2("buf_res2", {BT_CONST}, tiramisu::p_float32, a_output, &function0);
tiramisu::buffer buf_d1("buf_d1", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d1.set_auto_allocate(false);
tiramisu::computation *alloc_d1 = buf_d1.allocate_at(Res2, t);
tiramisu::buffer buf_d2("buf_d2", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d2.set_auto_allocate(false);
tiramisu::computation *alloc_d2 = buf_d2.allocate_at(Res2, t);
tiramisu::buffer buf_d3("buf_d3", {KMAX}, tiramisu::p_int32, a_temporary, &function0);
buf_d3.set_auto_allocate(false);
tiramisu::computation *alloc_d3 = buf_d3.allocate_at(Res2, t);
// S(d1, i3, i2, i1, t, a1, x’0)
tiramisu::buffer buf_S("buf_S", {tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), N_CONST, N_CONST, N_CONST, tiramisu::expr((int32_t) BARYON_P1)}, tiramisu::p_float32, a_input, &function0);
tiramisu::buffer buf_wp("buf_wp", {tiramisu::expr((int32_t) BARYON_N), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P), tiramisu::expr((int32_t) BARYON_P)}, tiramisu::p_float32, a_input, &function0);
fc1.store_in(&buf_fc1);
fc2.store_in(&buf_fc2);
fc3.store_in(&buf_fc3);
d1.store_in(&buf_d1, {0});
d2.store_in(&buf_d2, {0});
d3.store_in(&buf_d3, {0});
Res0.store_in(&buf_res0, {i3});
Res1.store_in(&buf_res1, {i3});
Res1_update_0.store_in(&buf_res1, {i3});
Res2.store_in(&buf_res2, {t});
Res2_update_0.store_in(&buf_res2, {t});
S.store_in(&buf_S);
wp.store_in(&buf_wp);
// -------------------------------------------------------
// Layer II
// -------------------------------------------------------
Res2.then(*alloc_res1, t)
.then(*alloc_res0, t)
.then(*alloc_d1, t)
.then(*alloc_d2, t)
.then(*alloc_d3, t)
.then(Res1, i3)
.then(d1, i3)
.then(d2, k)
.then(d3, k)
.then(Res0, k)
.then(Res1_update_0, k)
.then(Res2_update_0, i2);
Res0.tag_vector_level(i3, BARYON_N);
Res2.tag_parallel_level(t);
// -------------------------------------------------------
// Code Generation
// -------------------------------------------------------
function0.set_arguments({&buf_res2, &buf_S, &buf_wp, &buf_fc1, &buf_fc2, &buf_fc3});
function0.gen_time_space_domain();
function0.gen_isl_ast();
function0.gen_halide_stmt();
function0.gen_halide_obj("generated_" + std::string(TEST_NAME_STR) + ".o");
}
int main(int argc, char **argv)
{
generate_function("tiramisu_generated_code", BARYON_N);
return 0;
}
<|endoftext|> |
<commit_before>/**
* Copyright (c) 2016-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
#include "args.h"
#include <stdlib.h>
#include <string.h>
#include <iostream>
Args::Args() {
lr = 0.05;
dim = 100;
ws = 5;
epoch = 5;
minCount = 5;
neg = 5;
wordNgrams = 1;
loss = loss_name::ns;
model = model_name::sg;
bucket = 2000000;
minn = 3;
maxn = 6;
thread = 12;
lrUpdateRate = 100;
t = 1e-4;
label = "__label__";
verbose = 2;
}
void Args::parseArgs(int argc, char** argv) {
std::string command(argv[1]);
if (command == "supervised") {
model = model_name::sup;
loss = loss_name::softmax;
minCount = 1;
minn = 0;
maxn = 0;
lr = 0.1;
} else if (command == "cbow") {
model = model_name::cbow;
}
int ai = 2;
while (ai < argc) {
if (argv[ai][0] != '-') {
std::cout << "Provided argument without a dash! Usage:" << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
if (strcmp(argv[ai], "-h") == 0) {
std::cout << "Here is the help! Usage:" << std::endl;
printHelp();
exit(EXIT_FAILURE);
} else if (strcmp(argv[ai], "-input") == 0) {
input = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-test") == 0) {
test = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-output") == 0) {
output = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-lr") == 0) {
lr = atof(argv[ai + 1]);
} else if (strcmp(argv[ai], "-lrUpdateRate") == 0) {
lrUpdateRate = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-dim") == 0) {
dim = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-ws") == 0) {
ws = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-epoch") == 0) {
epoch = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-minCount") == 0) {
minCount = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-neg") == 0) {
neg = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-wordNgrams") == 0) {
wordNgrams = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-loss") == 0) {
if (strcmp(argv[ai + 1], "hs") == 0) {
loss = loss_name::hs;
} else if (strcmp(argv[ai + 1], "ns") == 0) {
loss = loss_name::ns;
} else if (strcmp(argv[ai + 1], "softmax") == 0) {
loss = loss_name::softmax;
} else {
std::cout << "Unknown loss: " << argv[ai + 1] << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[ai], "-bucket") == 0) {
bucket = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-minn") == 0) {
minn = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-maxn") == 0) {
maxn = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-thread") == 0) {
thread = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-t") == 0) {
t = atof(argv[ai + 1]);
} else if (strcmp(argv[ai], "-label") == 0) {
label = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-verbose") == 0) {
verbose = atoi(argv[ai + 1]);
} else {
std::cout << "Unknown argument: " << argv[ai] << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
ai += 2;
}
if (input.empty() || output.empty()) {
std::cout << "Empty input or output path." << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
if (wordNgrams <= 1 && maxn == 0) {
bucket = 0;
}
}
void Args::printHelp() {
std::cout
<< "\n"
<< "The following arguments are mandatory:\n"
<< " -input training file path\n"
<< " -output output file path\n\n"
<< "The following arguments are optional:\n"
<< " -lr learning rate [" << lr << "]\n"
<< " -lrUpdateRate change the rate of updates for the learning rate [" << lrUpdateRate << "]\n"
<< " -dim size of word vectors [" << dim << "]\n"
<< " -ws size of the context window [" << ws << "]\n"
<< " -epoch number of epochs [" << epoch << "]\n"
<< " -minCount minimal number of word occurences [" << minCount << "]\n"
<< " -neg number of negatives sampled [" << neg << "]\n"
<< " -wordNgrams max length of word ngram [" << wordNgrams << "]\n"
<< " -loss loss function {ns, hs, softmax} [ns]\n"
<< " -bucket number of buckets [" << bucket << "]\n"
<< " -minn min length of char ngram [" << minn << "]\n"
<< " -maxn max length of char ngram [" << maxn << "]\n"
<< " -thread number of threads [" << thread << "]\n"
<< " -t sampling threshold [" << t << "]\n"
<< " -label labels prefix [" << label << "]\n"
<< " -verbose verbosity level [" << verbose << "]\n"
<< std::endl;
}
void Args::save(std::ostream& out) {
out.write((char*) &(dim), sizeof(int));
out.write((char*) &(ws), sizeof(int));
out.write((char*) &(epoch), sizeof(int));
out.write((char*) &(minCount), sizeof(int));
out.write((char*) &(neg), sizeof(int));
out.write((char*) &(wordNgrams), sizeof(int));
out.write((char*) &(loss), sizeof(loss_name));
out.write((char*) &(model), sizeof(model_name));
out.write((char*) &(bucket), sizeof(int));
out.write((char*) &(minn), sizeof(int));
out.write((char*) &(maxn), sizeof(int));
out.write((char*) &(lrUpdateRate), sizeof(int));
out.write((char*) &(t), sizeof(double));
}
void Args::load(std::istream& in) {
in.read((char*) &(dim), sizeof(int));
in.read((char*) &(ws), sizeof(int));
in.read((char*) &(epoch), sizeof(int));
in.read((char*) &(minCount), sizeof(int));
in.read((char*) &(neg), sizeof(int));
in.read((char*) &(wordNgrams), sizeof(int));
in.read((char*) &(loss), sizeof(loss_name));
in.read((char*) &(model), sizeof(model_name));
in.read((char*) &(bucket), sizeof(int));
in.read((char*) &(minn), sizeof(int));
in.read((char*) &(maxn), sizeof(int));
in.read((char*) &(lrUpdateRate), sizeof(int));
in.read((char*) &(t), sizeof(double));
}
<commit_msg>Fix printHelp function<commit_after>/**
* Copyright (c) 2016-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
#include "args.h"
#include <stdlib.h>
#include <string.h>
#include <iostream>
Args::Args() {
lr = 0.05;
dim = 100;
ws = 5;
epoch = 5;
minCount = 5;
neg = 5;
wordNgrams = 1;
loss = loss_name::ns;
model = model_name::sg;
bucket = 2000000;
minn = 3;
maxn = 6;
thread = 12;
lrUpdateRate = 100;
t = 1e-4;
label = "__label__";
verbose = 2;
}
void Args::parseArgs(int argc, char** argv) {
std::string command(argv[1]);
if (command == "supervised") {
model = model_name::sup;
loss = loss_name::softmax;
minCount = 1;
minn = 0;
maxn = 0;
lr = 0.1;
} else if (command == "cbow") {
model = model_name::cbow;
}
int ai = 2;
while (ai < argc) {
if (argv[ai][0] != '-') {
std::cout << "Provided argument without a dash! Usage:" << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
if (strcmp(argv[ai], "-h") == 0) {
std::cout << "Here is the help! Usage:" << std::endl;
printHelp();
exit(EXIT_FAILURE);
} else if (strcmp(argv[ai], "-input") == 0) {
input = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-test") == 0) {
test = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-output") == 0) {
output = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-lr") == 0) {
lr = atof(argv[ai + 1]);
} else if (strcmp(argv[ai], "-lrUpdateRate") == 0) {
lrUpdateRate = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-dim") == 0) {
dim = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-ws") == 0) {
ws = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-epoch") == 0) {
epoch = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-minCount") == 0) {
minCount = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-neg") == 0) {
neg = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-wordNgrams") == 0) {
wordNgrams = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-loss") == 0) {
if (strcmp(argv[ai + 1], "hs") == 0) {
loss = loss_name::hs;
} else if (strcmp(argv[ai + 1], "ns") == 0) {
loss = loss_name::ns;
} else if (strcmp(argv[ai + 1], "softmax") == 0) {
loss = loss_name::softmax;
} else {
std::cout << "Unknown loss: " << argv[ai + 1] << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
} else if (strcmp(argv[ai], "-bucket") == 0) {
bucket = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-minn") == 0) {
minn = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-maxn") == 0) {
maxn = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-thread") == 0) {
thread = atoi(argv[ai + 1]);
} else if (strcmp(argv[ai], "-t") == 0) {
t = atof(argv[ai + 1]);
} else if (strcmp(argv[ai], "-label") == 0) {
label = std::string(argv[ai + 1]);
} else if (strcmp(argv[ai], "-verbose") == 0) {
verbose = atoi(argv[ai + 1]);
} else {
std::cout << "Unknown argument: " << argv[ai] << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
ai += 2;
}
if (input.empty() || output.empty()) {
std::cout << "Empty input or output path." << std::endl;
printHelp();
exit(EXIT_FAILURE);
}
if (wordNgrams <= 1 && maxn == 0) {
bucket = 0;
}
}
void Args::printHelp() {
std::string lname = "ns";
if (loss == loss_name::hs) lname = "hs";
if (loss == loss_name::softmax) lname = "softmax";
std::cout
<< "\n"
<< "The following arguments are mandatory:\n"
<< " -input training file path\n"
<< " -output output file path\n\n"
<< "The following arguments are optional:\n"
<< " -lr learning rate [" << lr << "]\n"
<< " -lrUpdateRate change the rate of updates for the learning rate [" << lrUpdateRate << "]\n"
<< " -dim size of word vectors [" << dim << "]\n"
<< " -ws size of the context window [" << ws << "]\n"
<< " -epoch number of epochs [" << epoch << "]\n"
<< " -minCount minimal number of word occurences [" << minCount << "]\n"
<< " -neg number of negatives sampled [" << neg << "]\n"
<< " -wordNgrams max length of word ngram [" << wordNgrams << "]\n"
<< " -loss loss function {ns, hs, softmax} [" << lname << "]\n"
<< " -bucket number of buckets [" << bucket << "]\n"
<< " -minn min length of char ngram [" << minn << "]\n"
<< " -maxn max length of char ngram [" << maxn << "]\n"
<< " -thread number of threads [" << thread << "]\n"
<< " -t sampling threshold [" << t << "]\n"
<< " -label labels prefix [" << label << "]\n"
<< " -verbose verbosity level [" << verbose << "]\n"
<< std::endl;
}
void Args::save(std::ostream& out) {
out.write((char*) &(dim), sizeof(int));
out.write((char*) &(ws), sizeof(int));
out.write((char*) &(epoch), sizeof(int));
out.write((char*) &(minCount), sizeof(int));
out.write((char*) &(neg), sizeof(int));
out.write((char*) &(wordNgrams), sizeof(int));
out.write((char*) &(loss), sizeof(loss_name));
out.write((char*) &(model), sizeof(model_name));
out.write((char*) &(bucket), sizeof(int));
out.write((char*) &(minn), sizeof(int));
out.write((char*) &(maxn), sizeof(int));
out.write((char*) &(lrUpdateRate), sizeof(int));
out.write((char*) &(t), sizeof(double));
}
void Args::load(std::istream& in) {
in.read((char*) &(dim), sizeof(int));
in.read((char*) &(ws), sizeof(int));
in.read((char*) &(epoch), sizeof(int));
in.read((char*) &(minCount), sizeof(int));
in.read((char*) &(neg), sizeof(int));
in.read((char*) &(wordNgrams), sizeof(int));
in.read((char*) &(loss), sizeof(loss_name));
in.read((char*) &(model), sizeof(model_name));
in.read((char*) &(bucket), sizeof(int));
in.read((char*) &(minn), sizeof(int));
in.read((char*) &(maxn), sizeof(int));
in.read((char*) &(lrUpdateRate), sizeof(int));
in.read((char*) &(t), sizeof(double));
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2014-2019 AscEmu Team <http://www.ascemu.org>
This file is released under the MIT license. See README-MIT for more information.
*/
#include "StdAfx.h"
#include "Server/Packets/CmsgAuctionListOwnerItems.h"
#include "Server/Packets/CmsgAuctionListItems.h"
#include "Server/Packets/CmsgAuctionRemoveItem.h"
#include "Server/Packets/SmsgAuctionCommandResult.h"
#include "Server/Packets/CmsgAuctionListIBidderItemse.h"
#include "Server/Packets/CmsgAuctionListIPendingSales.h"
#include "Server/Packets/CmsgAuctionPlaceBid.h"
#include "Server/Packets/CmsgAuctionSellItem.h"
#include "Server/WorldSession.h"
#include "Units/Players/Player.h"
#include "Map/MapMgr.h"
#include "Units/Creatures/Creature.h"
#include "Management/AuctionMgr.h"
#include "Management/ItemInterface.h"
using namespace AscEmu::Packets;
void WorldSession::handleAuctionListOwnerItems(WorldPacket& recvPacket)
{
CmsgAuctionListOwnerItems srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_OWNER_ITEMS %u (guidLow)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendOwnerListPacket(_player, nullptr);
}
void WorldSession::handleAuctionListItems(WorldPacket& recvPacket)
{
CmsgAuctionListItems srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_OWNER_ITEMS %u (guidLow)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendAuctionList(_player, &recvPacket);
}
void WorldSession::handleCancelAuction(WorldPacket& recvPacket)
{
CmsgAuctionRemoveItem srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_REMOVE_ITEM %u (auctionId)", srlPacket.auctionId);
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auction = creature->auctionHouse->GetAuction(srlPacket.auctionId);
if (auction == nullptr)
return;
creature->auctionHouse->QueueDeletion(auction, AUCTION_REMOVE_CANCELLED);
SendPacket(SmsgAuctionCommandResult(srlPacket.auctionId, AUCTION_CANCEL, AUCTION_ERROR_NONE).serialise().get());
creature->auctionHouse->SendOwnerListPacket(_player, nullptr);
}
void WorldSession::handleAuctionListBidderItems(WorldPacket& recvPacket)
{
CmsgAuctionListIBidderItemse srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_BIDDER_ITEMS %u (lowguid)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendBidListPacket(_player, &recvPacket);
}
void WorldSession::handleAuctionListPendingSales(WorldPacket& recvPacket)
{
#if VERSION_STRING > TBC
CmsgAuctionListIPendingSales srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_PRENDING_SALES %u (lowguid)", srlPacket.guid.getGuidLow());
//\todo SMSG_AUCTION_LIST_PENDING_SALES needs to be researched!
#endif
}
void WorldSession::handleAuctionSellItem(WorldPacket& recvPacket)
{
CmsgAuctionSellItem srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_SELL_ITEM");
if (!srlPacket.bidMoney || !srlPacket.expireTime)
return;
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.auctioneerGuid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auctionHouse = creature->auctionHouse;
srlPacket.expireTime *= MINUTE;
switch (srlPacket.expireTime)
{
case 1 * MIN_AUCTION_TIME:
case 2 * MIN_AUCTION_TIME:
case 4 * MIN_AUCTION_TIME:
break;
default:
return;
}
Item* items[MAX_AUCTION_ITEMS];
uint32_t finalCount = 0;
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
const auto item = _player->getItemInterface()->GetItemByGUID(srlPacket.itemGuids[i]);
if (!item)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_ITEM);
return;
}
items[i] = item;
finalCount += srlPacket.count[i];
}
if (!finalCount)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
if (items[i] == nullptr || items[i]->getStackCount() < finalCount)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
}
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
if (items[i] == nullptr)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
const uint32_t item_worth = items[i]->getItemProperties()->SellPrice * items[i]->getStackCount();
const uint32_t item_deposit = static_cast<uint32_t>(item_worth * auctionHouse->deposit_percent) * static_cast<uint32_t>(srlPacket.expireTime / 240.0f);
if (!_player->hasEnoughCoinage(item_deposit))
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_MONEY);
return;
}
_player->modCoinage(-int32(item_deposit));
const auto item = _player->getItemInterface()->SafeRemoveAndRetreiveItemByGuid(srlPacket.itemGuids[i], false);
if (!item)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_ITEM);
return;
};
if (item->IsInWorld())
item->RemoveFromWorld();
item->setOwner(nullptr);
item->m_isDirty = true;
item->SaveToDB(INVENTORY_SLOT_NOT_SET, 0, true, nullptr);
const auto auction = new Auction;
auction->BuyoutPrice = static_cast<uint32_t>(srlPacket.buyoutPrice);
auction->ExpiryTime = static_cast<uint32_t>(UNIXTIME) + srlPacket.expireTime * MINUTE;
auction->StartingPrice = static_cast<uint32_t>(srlPacket.bidMoney);
auction->HighestBid = 0;
auction->HighestBidder = 0;
auction->Id = sAuctionMgr.GenerateAuctionId();
auction->Owner = _player->getGuidLow();
auction->pItem = item;
auction->Deleted = false;
auction->DeletedReason = 0;
auction->DepositAmount = item_deposit;
auctionHouse->AddAuction(auction);
auction->SaveToDB(auctionHouse->GetID());
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_NONE);
}
auctionHouse->SendOwnerListPacket(_player, &recvPacket);
}
void WorldSession::handleAuctionPlaceBid(WorldPacket& recvPacket)
{
CmsgAuctionPlaceBid srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_PLACE_BID: %u (auctionId), %u (price)", srlPacket.auctionId, srlPacket.price);
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auctionHouse = creature->auctionHouse;
const auto auction = auctionHouse->GetAuction(srlPacket.auctionId);
if (auction == nullptr || !auction->Owner || _player == nullptr)
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_INTERNAL, 0).serialise().get());
return;
}
if (auction->Owner == _player->getGuidLow())
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_BID_OWN_AUCTION, 0).serialise().get());
return;
}
if (auction->HighestBid > srlPacket.price && srlPacket.price != auction->BuyoutPrice)
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_INTERNAL, 0).serialise().get());
return;
}
if (!_player->hasEnoughCoinage(srlPacket.price))
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_MONEY, 0).serialise().get());
return;
}
_player->modCoinage(-static_cast<int32_t>(srlPacket.price));
if (auction->HighestBidder != 0)
{
char subject[100];
snprintf(subject, 100, "%u:0:0", static_cast<int>(auction->pItem->getEntry()));
sMailSystem.SendAutomatedMessage(MAIL_TYPE_AUCTION, auctionHouse->GetID(), auction->HighestBidder, subject, "", auction->HighestBid, 0, 0, MAIL_STATIONERY_AUCTION);
if (auction->HighestBidder != _player->getGuidLow())
auctionHouse->SendAuctionOutBidNotificationPacket(auction, _player->getGuid(), srlPacket.price);
}
if (auction->BuyoutPrice == srlPacket.price)
{
auction->HighestBidder = _player->getGuidLow();
auction->HighestBid = srlPacket.price;
auctionHouse->QueueDeletion(auction, AUCTION_REMOVE_WON);
SendPacket(SmsgAuctionCommandResult(auction->Id, AUCTION_BID, AUCTION_ERROR_NONE, 0).serialise().get());
auctionHouse->SendAuctionBuyOutNotificationPacket(auction);
}
else
{
auction->HighestBidder = _player->getGuidLow();
auction->HighestBid = srlPacket.price;
auction->UpdateInDB();
SendPacket(SmsgAuctionCommandResult(auction->Id, AUCTION_BID, AUCTION_ERROR_NONE, 0).serialise().get());
}
}
<commit_msg>Resolved CID 351862 (#1 of 1): Dereference before null check<commit_after>/*
Copyright (c) 2014-2019 AscEmu Team <http://www.ascemu.org>
This file is released under the MIT license. See README-MIT for more information.
*/
#include "StdAfx.h"
#include "Server/Packets/CmsgAuctionListOwnerItems.h"
#include "Server/Packets/CmsgAuctionListItems.h"
#include "Server/Packets/CmsgAuctionRemoveItem.h"
#include "Server/Packets/SmsgAuctionCommandResult.h"
#include "Server/Packets/CmsgAuctionListIBidderItemse.h"
#include "Server/Packets/CmsgAuctionListIPendingSales.h"
#include "Server/Packets/CmsgAuctionPlaceBid.h"
#include "Server/Packets/CmsgAuctionSellItem.h"
#include "Server/WorldSession.h"
#include "Units/Players/Player.h"
#include "Map/MapMgr.h"
#include "Units/Creatures/Creature.h"
#include "Management/AuctionMgr.h"
#include "Management/ItemInterface.h"
using namespace AscEmu::Packets;
void WorldSession::handleAuctionListOwnerItems(WorldPacket& recvPacket)
{
CmsgAuctionListOwnerItems srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_OWNER_ITEMS %u (guidLow)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendOwnerListPacket(_player, nullptr);
}
void WorldSession::handleAuctionListItems(WorldPacket& recvPacket)
{
CmsgAuctionListItems srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_OWNER_ITEMS %u (guidLow)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendAuctionList(_player, &recvPacket);
}
void WorldSession::handleCancelAuction(WorldPacket& recvPacket)
{
CmsgAuctionRemoveItem srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_REMOVE_ITEM %u (auctionId)", srlPacket.auctionId);
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auction = creature->auctionHouse->GetAuction(srlPacket.auctionId);
if (auction == nullptr)
return;
creature->auctionHouse->QueueDeletion(auction, AUCTION_REMOVE_CANCELLED);
SendPacket(SmsgAuctionCommandResult(srlPacket.auctionId, AUCTION_CANCEL, AUCTION_ERROR_NONE).serialise().get());
creature->auctionHouse->SendOwnerListPacket(_player, nullptr);
}
void WorldSession::handleAuctionListBidderItems(WorldPacket& recvPacket)
{
CmsgAuctionListIBidderItemse srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_BIDDER_ITEMS %u (lowguid)", srlPacket.guid.getGuidLow());
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
creature->auctionHouse->SendBidListPacket(_player, &recvPacket);
}
void WorldSession::handleAuctionListPendingSales(WorldPacket& recvPacket)
{
#if VERSION_STRING > TBC
CmsgAuctionListIPendingSales srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_LIST_PRENDING_SALES %u (lowguid)", srlPacket.guid.getGuidLow());
//\todo SMSG_AUCTION_LIST_PENDING_SALES needs to be researched!
#endif
}
void WorldSession::handleAuctionSellItem(WorldPacket& recvPacket)
{
CmsgAuctionSellItem srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_SELL_ITEM");
if (!srlPacket.bidMoney || !srlPacket.expireTime)
return;
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.auctioneerGuid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auctionHouse = creature->auctionHouse;
srlPacket.expireTime *= MINUTE;
switch (srlPacket.expireTime)
{
case 1 * MIN_AUCTION_TIME:
case 2 * MIN_AUCTION_TIME:
case 4 * MIN_AUCTION_TIME:
break;
default:
return;
}
Item* items[MAX_AUCTION_ITEMS];
uint32_t finalCount = 0;
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
const auto item = _player->getItemInterface()->GetItemByGUID(srlPacket.itemGuids[i]);
if (!item)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_ITEM);
return;
}
items[i] = item;
finalCount += srlPacket.count[i];
}
if (!finalCount)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
if (items[i] == nullptr || items[i]->getStackCount() < finalCount)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
}
for (uint32_t i = 0; i < srlPacket.itemsCount; ++i)
{
if (items[i] == nullptr)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_INTERNAL);
return;
}
const uint32_t item_worth = items[i]->getItemProperties()->SellPrice * items[i]->getStackCount();
const uint32_t item_deposit = static_cast<uint32_t>(item_worth * auctionHouse->deposit_percent) * static_cast<uint32_t>(srlPacket.expireTime / 240.0f);
if (!_player->hasEnoughCoinage(item_deposit))
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_MONEY);
return;
}
_player->modCoinage(-int32(item_deposit));
const auto item = _player->getItemInterface()->SafeRemoveAndRetreiveItemByGuid(srlPacket.itemGuids[i], false);
if (!item)
{
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_ITEM);
return;
};
if (item->IsInWorld())
item->RemoveFromWorld();
item->setOwner(nullptr);
item->m_isDirty = true;
item->SaveToDB(INVENTORY_SLOT_NOT_SET, 0, true, nullptr);
const auto auction = new Auction;
auction->BuyoutPrice = static_cast<uint32_t>(srlPacket.buyoutPrice);
auction->ExpiryTime = static_cast<uint32_t>(UNIXTIME) + srlPacket.expireTime * MINUTE;
auction->StartingPrice = static_cast<uint32_t>(srlPacket.bidMoney);
auction->HighestBid = 0;
auction->HighestBidder = 0;
auction->Id = sAuctionMgr.GenerateAuctionId();
auction->Owner = _player->getGuidLow();
auction->pItem = item;
auction->Deleted = false;
auction->DeletedReason = 0;
auction->DepositAmount = item_deposit;
auctionHouse->AddAuction(auction);
auction->SaveToDB(auctionHouse->GetID());
_player->sendAuctionCommandResult(nullptr, AUCTION_CREATE, AUCTION_ERROR_NONE);
}
auctionHouse->SendOwnerListPacket(_player, &recvPacket);
}
void WorldSession::handleAuctionPlaceBid(WorldPacket& recvPacket)
{
CmsgAuctionPlaceBid srlPacket;
if (!srlPacket.deserialise(recvPacket))
return;
LogDebugFlag(LF_OPCODE, "Received CMSG_AUCTION_PLACE_BID: %u (auctionId), %u (price)", srlPacket.auctionId, srlPacket.price);
const auto creature = _player->GetMapMgr()->GetCreature(srlPacket.guid.getGuidLow());
if (creature == nullptr || creature->auctionHouse == nullptr)
return;
const auto auctionHouse = creature->auctionHouse;
const auto auction = auctionHouse->GetAuction(srlPacket.auctionId);
if (auction == nullptr || !auction->Owner)
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_INTERNAL, 0).serialise().get());
return;
}
if (auction->Owner == _player->getGuidLow())
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_BID_OWN_AUCTION, 0).serialise().get());
return;
}
if (auction->HighestBid > srlPacket.price && srlPacket.price != auction->BuyoutPrice)
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_INTERNAL, 0).serialise().get());
return;
}
if (!_player->hasEnoughCoinage(srlPacket.price))
{
SendPacket(SmsgAuctionCommandResult(0, AUCTION_BID, AUCTION_ERROR_MONEY, 0).serialise().get());
return;
}
_player->modCoinage(-static_cast<int32_t>(srlPacket.price));
if (auction->HighestBidder != 0)
{
char subject[100];
snprintf(subject, 100, "%u:0:0", static_cast<int>(auction->pItem->getEntry()));
sMailSystem.SendAutomatedMessage(MAIL_TYPE_AUCTION, auctionHouse->GetID(), auction->HighestBidder, subject, "", auction->HighestBid, 0, 0, MAIL_STATIONERY_AUCTION);
if (auction->HighestBidder != _player->getGuidLow())
auctionHouse->SendAuctionOutBidNotificationPacket(auction, _player->getGuid(), srlPacket.price);
}
if (auction->BuyoutPrice == srlPacket.price)
{
auction->HighestBidder = _player->getGuidLow();
auction->HighestBid = srlPacket.price;
auctionHouse->QueueDeletion(auction, AUCTION_REMOVE_WON);
SendPacket(SmsgAuctionCommandResult(auction->Id, AUCTION_BID, AUCTION_ERROR_NONE, 0).serialise().get());
auctionHouse->SendAuctionBuyOutNotificationPacket(auction);
}
else
{
auction->HighestBidder = _player->getGuidLow();
auction->HighestBid = srlPacket.price;
auction->UpdateInDB();
SendPacket(SmsgAuctionCommandResult(auction->Id, AUCTION_BID, AUCTION_ERROR_NONE, 0).serialise().get());
}
}
<|endoftext|> |
<commit_before>// Copyright (c) 2009 The Chromium Authors. All rights reserved. Use of this
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
#include <gtk/gtk.h>
#include "views/controls/combobox/native_combobox_gtk.h"
#include "app/combobox_model.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "views/controls/combobox/combobox.h"
namespace views {
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, public:
NativeComboboxGtk::NativeComboboxGtk(Combobox* combobox)
: combobox_(combobox) {
set_focus_view(combobox);
}
NativeComboboxGtk::~NativeComboboxGtk() {
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, NativeComboboxWrapper implementation:
void NativeComboboxGtk::UpdateFromModel() {
if (!native_view())
return;
preferred_size_ = gfx::Size();
GtkListStore* store =
GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(native_view())));
ComboboxModel* model = combobox_->model();
int count = model->GetItemCount();
gtk_list_store_clear(store);
GtkTreeIter iter;
while (count-- > 0) {
gtk_list_store_prepend(store, &iter);
gtk_list_store_set(store, &iter,
0, WideToUTF8(model->GetItemAt(count)).c_str(),
-1);
}
}
void NativeComboboxGtk::UpdateSelectedItem() {
if (!native_view())
return;
gtk_combo_box_set_active(
GTK_COMBO_BOX(native_view()), combobox_->selected_item());
}
void NativeComboboxGtk::UpdateEnabled() {
SetEnabled(combobox_->IsEnabled());
}
int NativeComboboxGtk::GetSelectedItem() const {
if (!native_view())
return 0;
return gtk_combo_box_get_active(GTK_COMBO_BOX(native_view()));
}
bool NativeComboboxGtk::IsDropdownOpen() const {
if (!native_view())
return false;
gboolean popup_shown;
g_object_get(G_OBJECT(native_view()), "popup-shown", &popup_shown, NULL);
return popup_shown;
}
gfx::Size NativeComboboxGtk::GetPreferredSize() {
if (!native_view())
return gfx::Size();
if (preferred_size_.IsEmpty()) {
GtkRequisition size_request = { 0, 0 };
gtk_widget_size_request(native_view(), &size_request);
// TODO(oshima|scott): we may not need ::max to 29. revisit this.
preferred_size_.SetSize(size_request.width,
std::max(size_request.height, 29));
}
return preferred_size_;
}
View* NativeComboboxGtk::GetView() {
return this;
}
void NativeComboboxGtk::SetFocus() {
Focus();
}
gfx::NativeView NativeComboboxGtk::GetTestingHandle() const {
return native_view();
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, NativeControlGtk overrides:
void NativeComboboxGtk::CreateNativeControl() {
GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
GtkWidget* widget = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
GtkCellRenderer* cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), cell, TRUE);
gtk_cell_layout_set_attributes(
GTK_CELL_LAYOUT(widget), cell, "text", 0, NULL);
g_signal_connect(G_OBJECT(widget), "changed",
G_CALLBACK(CallChanged), this);
NativeControlCreated(widget);
}
void NativeComboboxGtk::NativeControlCreated(GtkWidget* native_control) {
NativeControlGtk::NativeControlCreated(native_control);
// Set the data from combobox
UpdateFromModel();
// and show the 1st item by default.
gtk_combo_box_set_active(GTK_COMBO_BOX(native_control), 0);
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, private:
void NativeComboboxGtk::SelectionChanged() {
combobox_->SelectionChanged();
}
// static
void NativeComboboxGtk::CallChanged(GtkWidget* widget,
NativeComboboxGtk* combo) {
combo->SelectionChanged();
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxWrapper, public:
// static
NativeComboboxWrapper* NativeComboboxWrapper::CreateWrapper(
Combobox* combobox) {
return new NativeComboboxGtk(combobox);
}
} // namespace views
<commit_msg>style fix. the header for .cc has to be the 1st include.<commit_after>// Copyright (c) 2009 The Chromium Authors. All rights reserved. Use of this
// source code is governed by a BSD-style license that can be found in the
// LICENSE file.
#include "views/controls/combobox/native_combobox_gtk.h"
#include <gtk/gtk.h>
#include "app/combobox_model.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "views/controls/combobox/combobox.h"
namespace views {
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, public:
NativeComboboxGtk::NativeComboboxGtk(Combobox* combobox)
: combobox_(combobox) {
set_focus_view(combobox);
}
NativeComboboxGtk::~NativeComboboxGtk() {
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, NativeComboboxWrapper implementation:
void NativeComboboxGtk::UpdateFromModel() {
if (!native_view())
return;
preferred_size_ = gfx::Size();
GtkListStore* store =
GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(native_view())));
ComboboxModel* model = combobox_->model();
int count = model->GetItemCount();
gtk_list_store_clear(store);
GtkTreeIter iter;
while (count-- > 0) {
gtk_list_store_prepend(store, &iter);
gtk_list_store_set(store, &iter,
0, WideToUTF8(model->GetItemAt(count)).c_str(),
-1);
}
}
void NativeComboboxGtk::UpdateSelectedItem() {
if (!native_view())
return;
gtk_combo_box_set_active(
GTK_COMBO_BOX(native_view()), combobox_->selected_item());
}
void NativeComboboxGtk::UpdateEnabled() {
SetEnabled(combobox_->IsEnabled());
}
int NativeComboboxGtk::GetSelectedItem() const {
if (!native_view())
return 0;
return gtk_combo_box_get_active(GTK_COMBO_BOX(native_view()));
}
bool NativeComboboxGtk::IsDropdownOpen() const {
if (!native_view())
return false;
gboolean popup_shown;
g_object_get(G_OBJECT(native_view()), "popup-shown", &popup_shown, NULL);
return popup_shown;
}
gfx::Size NativeComboboxGtk::GetPreferredSize() {
if (!native_view())
return gfx::Size();
if (preferred_size_.IsEmpty()) {
GtkRequisition size_request = { 0, 0 };
gtk_widget_size_request(native_view(), &size_request);
// TODO(oshima|scott): we may not need ::max to 29. revisit this.
preferred_size_.SetSize(size_request.width,
std::max(size_request.height, 29));
}
return preferred_size_;
}
View* NativeComboboxGtk::GetView() {
return this;
}
void NativeComboboxGtk::SetFocus() {
Focus();
}
gfx::NativeView NativeComboboxGtk::GetTestingHandle() const {
return native_view();
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, NativeControlGtk overrides:
void NativeComboboxGtk::CreateNativeControl() {
GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
GtkWidget* widget = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
GtkCellRenderer* cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), cell, TRUE);
gtk_cell_layout_set_attributes(
GTK_CELL_LAYOUT(widget), cell, "text", 0, NULL);
g_signal_connect(G_OBJECT(widget), "changed",
G_CALLBACK(CallChanged), this);
NativeControlCreated(widget);
}
void NativeComboboxGtk::NativeControlCreated(GtkWidget* native_control) {
NativeControlGtk::NativeControlCreated(native_control);
// Set the data from combobox
UpdateFromModel();
// and show the 1st item by default.
gtk_combo_box_set_active(GTK_COMBO_BOX(native_control), 0);
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxGtk, private:
void NativeComboboxGtk::SelectionChanged() {
combobox_->SelectionChanged();
}
// static
void NativeComboboxGtk::CallChanged(GtkWidget* widget,
NativeComboboxGtk* combo) {
combo->SelectionChanged();
}
////////////////////////////////////////////////////////////////////////////////
// NativeComboboxWrapper, public:
// static
NativeComboboxWrapper* NativeComboboxWrapper::CreateWrapper(
Combobox* combobox) {
return new NativeComboboxGtk(combobox);
}
} // namespace views
<|endoftext|> |
<commit_before>/**
@file ast.cpp
@brief Implementation file for AST-related classes
@copyright 2014 Assured Information Security, Inc.
@author Jacob Torrey <[email protected]>
Stores the implementations for the AST classes. Includes pretty-printing logic
and some operator overloads for AST manipulation and analysis.
*/
#include "ast.h"
#include "parser.h"
/**
Overload for the == operator to allow for simple comparison of two NIdentifiers
@param i1 First NIdentifier to compare
@param i2 Second NIdentifier to compare
@return true if the Identifiers resolve to the same value, false otherwise
*/
bool operator==(const NIdentifier & i1, const NIdentifier & i2)
{
return i1.value == i2.value;
}
/**
Overload for the << operator to allow pretty printing of AST objects and AST as a whole
@param os Output stream to print to
@param node Node to pretty-print
@return Output stream passed in
*/
std::ostream & operator<<(std::ostream & os, const Node & node)
{
node.print(os);
return os;
}
std::ostream & NBlock::print(std::ostream & os) const
{
os << "Block: {" << std::endl;
for (int i = 0; i < statements.size(); i++)
{
os << *(statements[i]) << std::endl;
}
os << "}" << std::endl;
return os;
}
std::ostream & NVariableDeclaration::print(std::ostream & os) const
{
if (!type.isList)
{
os << "Variable declared --- (" << type << " " << ident << ")";
}
else
{
os << "List declared --- (" << type << " " << ident << "[])";
}
if (initializationExpression != NULL)
{
os << " = " << *initializationExpression;
}
os << std::endl;
return os;
}
std::ostream & NFunctionDeclaration::print(std::ostream & os) const
{
os << "Function declared --- (" << type << " " << ident << "(";
for (int i = 0; i < variables.size(); i++)
{
os << *(variables[i]) << " ";
}
os << ") " << *body << ")";
os << std::endl;
return os;
}
std::ostream & NStructureDeclaration::print(std::ostream & os) const
{
os << "Struct declared --- (" << ident << " {";
for (int i = 0; i < members.size(); i++)
{
os << *(members[i]) << " ";
}
os << "})";
os << std::endl;
return os;
}
std::ostream & NAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << ident << " = " << expr << ")" << std::endl;
return os;
}
std::ostream & NListAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << list << " = " << expr << "<" << std::endl;
return os;
}
std::ostream & NStructureAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << structure << " = " << expr << ")" << std::endl;
return os;
}
std::ostream & NBinaryOperator::print(std::ostream & os) const
{
std::string symbol;
switch(op)
{
case TMUL:
symbol = "*";
break;
case TADD:
symbol = "+";
break;
case TDIV:
symbol = "/";
break;
case TSUB:
symbol = "-";
break;
case TMOD:
symbol = "%";
break;
case TBAND:
symbol = "&";
break;
case TBXOR:
symbol = "^";
break;
case TBOR:
symbol = "|";
break;
case TLNOT:
symbol = "!";
break;
case TLOR:
symbol = "||";
break;
case TLAND:
symbol = "&&";
break;
default:
symbol = "UNKNOWN OP";
break;
}
os << "(BINOP: " << lhs << " " << symbol << " " << rhs << ")" << std::endl;
return os;
}
std::ostream & NIdentifier::print(std::ostream & os) const
{
os << "Identifier: " << value;
return os;
}
std::ostream & NListAccess::print(std::ostream & os) const
{
os << "(List access: " << ident << "[" << index << "])";
return os;
}
std::ostream & NVariableAccess::print(std::ostream & os) const
{
os << "(Variable access: " << ident << ")";
return os;
}
std::ostream & NStructureAccess::print(std::ostream & os) const
{
os << "(Struct access: " << ident << "." << member << ")";
return os;
}
std::ostream & NReturn::print(std::ostream & os) const
{
os << "(Return: " << retExpr << ")";
os << std::endl;
return os;
}
std::ostream & NDouble::print(std::ostream & os) const
{
os << "DOUBLE:" << value;
return os;
}
std::ostream & NBool::print(std::ostream & os) const
{
os << "BOOL:" << value;
return os;
}
std::ostream & NInt::print(std::ostream & os) const
{
os << "INT:" << value;
return os;
}
std::ostream & NValue::print(std::ostream & os) const
{
os << "(Generic NValue)" << std::endl;
return os;
}
std::ostream & NUInt::print(std::ostream & os) const
{
os << "UINT:" << value;
return os;
}
std::ostream & NString::print(std::ostream & os) const
{
os << "STRING:" << value;
return os;
}
std::ostream & NLoopStatement::print(std::ostream & os) const
{
os << "Loop: " << list << " as " << asVar << std::endl;
os << "{" << loopBlock << "}" << std::endl;
return os;
}
std::ostream & NIfStatement::print(std::ostream & os) const
{
if (elseblock == NULL && elseif == NULL)
os << "If: (" << condition << ") then " << thenblock << std::endl;
if (elseblock != NULL && elseif == NULL)
os << "If: (" << condition << ") then: " << thenblock << " else: " << *(elseblock) << std::endl;
if (elseblock == NULL && elseif != NULL)
{
os << "If: (" << condition << ") then " << thenblock << std::endl;
os << "Else if: " << *(elseif) << std::endl;
}
if (elseblock != NULL && elseif != NULL)
{
os << "If: (" << condition << ") then " << thenblock << std::endl;
os << "Else if: " << *(elseif) << " else: " << *(elseblock) << std::endl;
}
return os;
}
std::ostream & NFunctionCall::print(std::ostream & os) const
{
os << "Function Call: " << ident << std::endl;
for (int i = 0; i < args.size(); i++)
{
os << args[i] << std::endl;
}
return os;
}
std::ostream & NList::print(std::ostream & os) const
{
os << "List: [";
for (int i = 0; i < value.size(); i++)
{
os << *(value[i]) << " ";
}
os << "]" << std::endl;
return os;
}
<commit_msg>Adding comments and improving print functions in ast.cpp<commit_after>/**
@file ast.cpp
@brief Implementation file for AST-related classes
@copyright 2014 Assured Information Security, Inc.
@author Jacob Torrey <[email protected]>
Stores the implementations for the AST classes. Includes pretty-printing logic
and some operator overloads for AST manipulation and analysis.
*/
#include "ast.h"
#include "parser.h"
/**
Overload for the == operator to allow for simple comparison of two NIdentifiers.
The NIdentifier values being compared are of type string, which represent the names of
variables, lists, structs, struct members, etc.
@param i1 First NIdentifier to compare
@param i2 Second NIdentifier to compare
@return true if the Identifiers resolve to the same value, false otherwise
*/
bool operator==(const NIdentifier & i1, const NIdentifier & i2)
{
return i1.value == i2.value;
}
/**
Overload for the << operator to allow pretty printing of AST objects and AST as a whole
@param os Output stream to print to
@param node Node to pretty-print
@return Output stream passed in
*/
std::ostream & operator<<(std::ostream & os, const Node & node)
{
node.print(os);
return os;
}
/**
Print function for NBlock objects in the AST. Each block is composed of a vector of
statements. This function iterators over the typedef std::vector<NStatement*> StatementList,
printing each each statement in a given block, and returning the output stream.
@param os Output stream to print to
@return Output stream passed in
*/
std::ostream & NBlock::print(std::ostream & os) const
{
os << "Block: {" << std::endl;
for (StatementList::const_iterator it = statements.begin(); it != statements.end(); ++it)
os << *(*it) << std::endl;
os << "}" << std::endl;
return os;
}
/**
Print function for NVariableDeclaration objects. There are three members of the
NVariableDeclaration object that are printed:
1) Type
2) NIdentifier (Variable name)
3) Associated value or RHS (optional)
The initializationExpression is the RHS in variable assignments (e.g. the 4 in int a = 4).
If initializationExpression is NULL, then the no value was assigned to variable (e.g. int a).
@param os Output stream to print to
@return Output stream passed in
*/
std::ostream & NVariableDeclaration::print(std::ostream & os) const
{
if (!type.isList)
{
os << "Variable declared --- (" << type << " " << ident << ")";
}
else
{
os << "List declared --- (" << type << " " << ident << "[])";
}
if (initializationExpression != NULL)
{
os << " = " << *initializationExpression;
}
os << std::endl;
return os;
}
/**
Print function for NFunctionDeclaration objects. It first prints the return type
and name of the function followed by the arguments contained within the
typedef std::vector<NVariableDeclaration *> VariableList. Then, the NBlock body
of the function is printed.
@param os Output stream to print to
@return Output stream passed in
*/
std::ostream & NFunctionDeclaration::print(std::ostream & os) const
{
os << "Function declared --- (" << type << " " << ident << "(";
for (VariableList::const_iterator it = variables.begin(); it != variables.end(); ++it)
os << *(*it) << ") ";
os << *body << ")";
os << std::endl;
return os;
}
std::ostream & NStructureDeclaration::print(std::ostream & os) const
{
os << "Struct declared --- (" << ident << " {";
for (int i = 0; i < members.size(); i++)
{
os << *(members[i]) << " ";
}
os << "})";
os << std::endl;
return os;
}
std::ostream & NAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << ident << " = " << expr << ")" << std::endl;
return os;
}
std::ostream & NListAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << list << " = " << expr << "<" << std::endl;
return os;
}
std::ostream & NStructureAssignmentStatement::print(std::ostream & os) const
{
os << "(Assignment: " << structure << " = " << expr << ")" << std::endl;
return os;
}
std::ostream & NBinaryOperator::print(std::ostream & os) const
{
std::string symbol;
switch(op)
{
case TMUL:
symbol = "*";
break;
case TADD:
symbol = "+";
break;
case TDIV:
symbol = "/";
break;
case TSUB:
symbol = "-";
break;
case TMOD:
symbol = "%";
break;
case TBAND:
symbol = "&";
break;
case TBXOR:
symbol = "^";
break;
case TBOR:
symbol = "|";
break;
case TLNOT:
symbol = "!";
break;
case TLOR:
symbol = "||";
break;
case TLAND:
symbol = "&&";
break;
default:
symbol = "UNKNOWN OP";
break;
}
os << "(BINOP: " << lhs << " " << symbol << " " << rhs << ")" << std::endl;
return os;
}
std::ostream & NIdentifier::print(std::ostream & os) const
{
os << "Identifier: " << value;
return os;
}
std::ostream & NListAccess::print(std::ostream & os) const
{
os << "(List access: " << ident << "[" << index << "])";
return os;
}
std::ostream & NVariableAccess::print(std::ostream & os) const
{
os << "(Variable access: " << ident << ")";
return os;
}
std::ostream & NStructureAccess::print(std::ostream & os) const
{
os << "(Struct access: " << ident << "." << member << ")";
return os;
}
std::ostream & NReturn::print(std::ostream & os) const
{
os << "(Return: " << retExpr << ")";
os << std::endl;
return os;
}
std::ostream & NDouble::print(std::ostream & os) const
{
os << "DOUBLE:" << value;
return os;
}
std::ostream & NBool::print(std::ostream & os) const
{
os << "BOOL:" << value;
return os;
}
std::ostream & NInt::print(std::ostream & os) const
{
os << "INT:" << value;
return os;
}
std::ostream & NValue::print(std::ostream & os) const
{
os << "(Generic NValue)" << std::endl;
return os;
}
std::ostream & NUInt::print(std::ostream & os) const
{
os << "UINT:" << value;
return os;
}
std::ostream & NString::print(std::ostream & os) const
{
os << "STRING:" << value;
return os;
}
std::ostream & NLoopStatement::print(std::ostream & os) const
{
os << "Loop: " << list << " as " << asVar << std::endl;
os << "{" << loopBlock << "}" << std::endl;
return os;
}
std::ostream & NIfStatement::print(std::ostream & os) const
{
if (elseblock == NULL && elseif == NULL)
os << "If: (" << condition << ") then " << thenblock << std::endl;
if (elseblock != NULL && elseif == NULL)
os << "If: (" << condition << ") then: " << thenblock << " else: " << *(elseblock) << std::endl;
if (elseblock == NULL && elseif != NULL)
{
os << "If: (" << condition << ") then " << thenblock << std::endl;
os << "Else if: " << *(elseif) << std::endl;
}
if (elseblock != NULL && elseif != NULL)
{
os << "If: (" << condition << ") then " << thenblock << std::endl;
os << "Else if: " << *(elseif) << " else: " << *(elseblock) << std::endl;
}
return os;
}
std::ostream & NFunctionCall::print(std::ostream & os) const
{
os << "Function Call: " << ident << std::endl;
for (int i = 0; i < args.size(); i++)
{
os << args[i] << std::endl;
}
return os;
}
std::ostream & NList::print(std::ostream & os) const
{
os << "List: [";
for (int i = 0; i < value.size(); i++)
{
os << *(value[i]) << " ";
}
os << "]" << std::endl;
return os;
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of the author 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
*/
#include "libtorrent/pch.hpp"
#include <string>
#include <stdexcept>
#include <sstream>
#include <iomanip>
#include <cctype>
#include <algorithm>
#include <iostream>
#include <limits>
#include <boost/optional.hpp>
#include <boost/array.hpp>
#include "libtorrent/assert.hpp"
#include "libtorrent/escape_string.hpp"
namespace libtorrent
{
// lexical_cast's result depends on the locale. We need
// a well defined result
boost::array<char, 3 + std::numeric_limits<size_type>::digits10> to_string(size_type n)
{
boost::array<char, 3 + std::numeric_limits<size_type>::digits10> ret;
char *p = &ret.back();;
*p = '\0';
unsigned_size_type un = n;
if (n < 0) un = -un;
do {
*--p = '0' + un % 10;
un /= 10;
} while (un);
if (n < 0) *--p = '-';
std::memmove(&ret.front(), p, sizeof(ret.elems));
return ret;
}
std::string unescape_string(std::string const& s)
{
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end(); ++i)
{
if(*i == '+')
{
ret += ' ';
}
else if (*i != '%')
{
ret += *i;
}
else
{
++i;
if (i == s.end())
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
int high;
if(*i >= '0' && *i <= '9') high = *i - '0';
else if(*i >= 'A' && *i <= 'F') high = *i + 10 - 'A';
else if(*i >= 'a' && *i <= 'f') high = *i + 10 - 'a';
else
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
++i;
if (i == s.end())
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
int low;
if(*i >= '0' && *i <= '9') low = *i - '0';
else if(*i >= 'A' && *i <= 'F') low = *i + 10 - 'A';
else if(*i >= 'a' && *i <= 'f') low = *i + 10 - 'a';
else
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
ret += char(high * 16 + low);
}
}
return ret;
}
std::string escape_string(const char* str, int len)
{
TORRENT_ASSERT(str != 0);
TORRENT_ASSERT(len >= 0);
// http://www.ietf.org/rfc/rfc2396.txt
// section 2.3
// some trackers seems to require that ' is escaped
// static const char unreserved_chars[] = "-_.!~*'()";
static const char unreserved_chars[] = "-_.!~*()"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
std::stringstream ret;
ret << std::hex << std::setfill('0');
for (int i = 0; i < len; ++i)
{
if (std::count(
unreserved_chars
, unreserved_chars+sizeof(unreserved_chars)-1
, *str))
{
ret << *str;
}
else
{
ret << '%'
<< std::setw(2)
<< (int)static_cast<unsigned char>(*str);
}
++str;
}
return ret.str();
}
std::string escape_path(const char* str, int len)
{
TORRENT_ASSERT(str != 0);
TORRENT_ASSERT(len >= 0);
static const char unreserved_chars[] = "/-_.!~*()"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
std::stringstream ret;
ret << std::hex << std::setfill('0');
for (int i = 0; i < len; ++i)
{
if (std::count(
unreserved_chars
, unreserved_chars+sizeof(unreserved_chars)-1
, *str))
{
ret << *str;
}
else
{
ret << '%'
<< std::setw(2)
<< (int)static_cast<unsigned char>(*str);
}
++str;
}
return ret.str();
}
std::string base64encode(const std::string& s)
{
static const char base64_table[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
unsigned char inbuf[3];
unsigned char outbuf[4];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
// available input is 1,2 or 3 bytes
// since we read 3 bytes at a time at most
int available_input = (std::min)(3, (int)std::distance(i, s.end()));
// clear input buffer
std::fill(inbuf, inbuf+3, 0);
// read a chunk of input into inbuf
std::copy(i, i + available_input, inbuf);
i += available_input;
// encode inbuf to outbuf
outbuf[0] = (inbuf[0] & 0xfc) >> 2;
outbuf[1] = ((inbuf[0] & 0x03) << 4) | ((inbuf [1] & 0xf0) >> 4);
outbuf[2] = ((inbuf[1] & 0x0f) << 2) | ((inbuf [2] & 0xc0) >> 6);
outbuf[3] = inbuf[2] & 0x3f;
// write output
for (int j = 0; j < available_input+1; ++j)
{
ret += base64_table[outbuf[j]];
}
// write pad
for (int j = 0; j < 3 - available_input; ++j)
{
ret += '=';
}
}
return ret;
}
std::string base32encode(std::string const& s)
{
static const char base32_table[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', '2', '3', '4', '5', '6', '7'
};
int input_output_mapping[] = {0, 2, 4, 5, 7, 8};
unsigned char inbuf[5];
unsigned char outbuf[8];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
int available_input = (std::min)(5, (int)std::distance(i, s.end()));
// clear input buffer
std::fill(inbuf, inbuf+5, 0);
// read a chunk of input into inbuf
std::copy(i, i + available_input, inbuf);
i += available_input;
// encode inbuf to outbuf
outbuf[0] = (inbuf[0] & 0xf8) >> 3;
outbuf[1] = ((inbuf[0] & 0x07) << 2) | ((inbuf[1] & 0xc0) >> 6);
outbuf[2] = ((inbuf[1] & 0x3e) >> 1);
outbuf[3] = ((inbuf[1] & 0x01) << 4) | ((inbuf[2] & 0xf0) >> 4);
outbuf[4] = ((inbuf[2] & 0x0f) << 1) | ((inbuf[3] & 0x80) >> 7);
outbuf[5] = ((inbuf[3] & 0x7c) >> 2);
outbuf[6] = ((inbuf[3] & 0x03) << 3) | ((inbuf[4] & 0xe0) >> 5);
outbuf[7] = inbuf[4] & 0x1f;
// write output
int num_out = input_output_mapping[available_input];
for (int j = 0; j < num_out; ++j)
{
ret += base32_table[outbuf[j]];
}
// write pad
for (int j = 0; j < 8 - num_out; ++j)
{
ret += '=';
}
}
return ret;
}
std::string base32decode(std::string const& s)
{
unsigned char inbuf[8];
unsigned char outbuf[5];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
int available_input = (std::min)(8, (int)std::distance(i, s.end()));
int pad_start = 0;
if (available_input < 8) pad_start = available_input;
// clear input buffer
std::fill(inbuf, inbuf+8, 0);
for (int j = 0; j < available_input; ++j)
{
char in = std::toupper(*i++);
if (in >= 'A' && in <= 'Z')
inbuf[j] = in - 'A';
else if (in >= '2' && in <= '7')
inbuf[j] = in - '2' + ('Z' - 'A') + 1;
else if (in == '=')
{
inbuf[j] = 0;
if (pad_start == 0) pad_start = j;
}
else if (in == '1')
inbuf[j] = 'I' - 'A';
else
return std::string();
TORRENT_ASSERT(inbuf[j] == (inbuf[j] & 0x1f));
}
// decode inbuf to outbuf
outbuf[0] = inbuf[0] << 3;
outbuf[0] |= inbuf[1] >> 2;
outbuf[1] = (inbuf[1] & 0x3) << 6;
outbuf[1] |= inbuf[2] << 1;
outbuf[1] |= (inbuf[3] & 0x10) >> 4;
outbuf[2] = (inbuf[3] & 0x0f) << 4;
outbuf[2] |= (inbuf[4] & 0x1e) >> 1;
outbuf[3] = (inbuf[4] & 0x01) << 7;
outbuf[3] |= (inbuf[5] & 0x1f) << 2;
outbuf[3] |= (inbuf[6] & 0x18) >> 3;
outbuf[4] = (inbuf[6] & 0x07) << 5;
outbuf[4] |= inbuf[7];
int input_output_mapping[] = {5, 1, 1, 2, 2, 3, 4, 4, 5};
int num_out = input_output_mapping[pad_start];
// write output
std::copy(outbuf, outbuf + num_out, std::back_inserter(ret));
}
return ret;
}
boost::optional<std::string> url_has_argument(
std::string const& url, std::string argument)
{
size_t i = url.find('?');
if (i == std::string::npos) return boost::optional<std::string>();
++i;
argument += '=';
if (url.compare(i, argument.size(), argument) == 0)
{
size_t pos = i + argument.size();
return url.substr(pos, url.find('&', pos) - pos);
}
argument.insert(0, "&");
i = url.find(argument, i);
if (i == std::string::npos) return boost::optional<std::string>();
size_t pos = i + argument.size();
return url.substr(pos, url.find('&', pos) - pos);
}
TORRENT_EXPORT std::string to_hex(std::string const& s)
{
std::string ret;
char const* digits = "0123456789abcdef";
for (std::string::const_iterator i = s.begin(); i != s.end(); ++i)
{
ret += digits[((unsigned char)*i) >> 4];
ret += digits[((unsigned char)*i) & 0xf];
}
return ret;
}
}
<commit_msg>added missing include<commit_after>/*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* 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.
* Neither the name of the author 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
*/
#include "libtorrent/pch.hpp"
#include <string>
#include <stdexcept>
#include <sstream>
#include <iomanip>
#include <cctype>
#include <algorithm>
#include <iostream>
#include <limits>
#include <cstring>
#include <boost/optional.hpp>
#include <boost/array.hpp>
#include "libtorrent/assert.hpp"
#include "libtorrent/escape_string.hpp"
namespace libtorrent
{
// lexical_cast's result depends on the locale. We need
// a well defined result
boost::array<char, 3 + std::numeric_limits<size_type>::digits10> to_string(size_type n)
{
boost::array<char, 3 + std::numeric_limits<size_type>::digits10> ret;
char *p = &ret.back();;
*p = '\0';
unsigned_size_type un = n;
if (n < 0) un = -un;
do {
*--p = '0' + un % 10;
un /= 10;
} while (un);
if (n < 0) *--p = '-';
std::memmove(&ret.front(), p, sizeof(ret.elems));
return ret;
}
std::string unescape_string(std::string const& s)
{
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end(); ++i)
{
if(*i == '+')
{
ret += ' ';
}
else if (*i != '%')
{
ret += *i;
}
else
{
++i;
if (i == s.end())
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
int high;
if(*i >= '0' && *i <= '9') high = *i - '0';
else if(*i >= 'A' && *i <= 'F') high = *i + 10 - 'A';
else if(*i >= 'a' && *i <= 'f') high = *i + 10 - 'a';
else
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
++i;
if (i == s.end())
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
int low;
if(*i >= '0' && *i <= '9') low = *i - '0';
else if(*i >= 'A' && *i <= 'F') low = *i + 10 - 'A';
else if(*i >= 'a' && *i <= 'f') low = *i + 10 - 'a';
else
#ifdef BOOST_NO_EXCEPTIONS
return ret;
#else
throw std::runtime_error("invalid escaped string");
#endif
ret += char(high * 16 + low);
}
}
return ret;
}
std::string escape_string(const char* str, int len)
{
TORRENT_ASSERT(str != 0);
TORRENT_ASSERT(len >= 0);
// http://www.ietf.org/rfc/rfc2396.txt
// section 2.3
// some trackers seems to require that ' is escaped
// static const char unreserved_chars[] = "-_.!~*'()";
static const char unreserved_chars[] = "-_.!~*()"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
std::stringstream ret;
ret << std::hex << std::setfill('0');
for (int i = 0; i < len; ++i)
{
if (std::count(
unreserved_chars
, unreserved_chars+sizeof(unreserved_chars)-1
, *str))
{
ret << *str;
}
else
{
ret << '%'
<< std::setw(2)
<< (int)static_cast<unsigned char>(*str);
}
++str;
}
return ret.str();
}
std::string escape_path(const char* str, int len)
{
TORRENT_ASSERT(str != 0);
TORRENT_ASSERT(len >= 0);
static const char unreserved_chars[] = "/-_.!~*()"
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789";
std::stringstream ret;
ret << std::hex << std::setfill('0');
for (int i = 0; i < len; ++i)
{
if (std::count(
unreserved_chars
, unreserved_chars+sizeof(unreserved_chars)-1
, *str))
{
ret << *str;
}
else
{
ret << '%'
<< std::setw(2)
<< (int)static_cast<unsigned char>(*str);
}
++str;
}
return ret.str();
}
std::string base64encode(const std::string& s)
{
static const char base64_table[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
unsigned char inbuf[3];
unsigned char outbuf[4];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
// available input is 1,2 or 3 bytes
// since we read 3 bytes at a time at most
int available_input = (std::min)(3, (int)std::distance(i, s.end()));
// clear input buffer
std::fill(inbuf, inbuf+3, 0);
// read a chunk of input into inbuf
std::copy(i, i + available_input, inbuf);
i += available_input;
// encode inbuf to outbuf
outbuf[0] = (inbuf[0] & 0xfc) >> 2;
outbuf[1] = ((inbuf[0] & 0x03) << 4) | ((inbuf [1] & 0xf0) >> 4);
outbuf[2] = ((inbuf[1] & 0x0f) << 2) | ((inbuf [2] & 0xc0) >> 6);
outbuf[3] = inbuf[2] & 0x3f;
// write output
for (int j = 0; j < available_input+1; ++j)
{
ret += base64_table[outbuf[j]];
}
// write pad
for (int j = 0; j < 3 - available_input; ++j)
{
ret += '=';
}
}
return ret;
}
std::string base32encode(std::string const& s)
{
static const char base32_table[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', '2', '3', '4', '5', '6', '7'
};
int input_output_mapping[] = {0, 2, 4, 5, 7, 8};
unsigned char inbuf[5];
unsigned char outbuf[8];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
int available_input = (std::min)(5, (int)std::distance(i, s.end()));
// clear input buffer
std::fill(inbuf, inbuf+5, 0);
// read a chunk of input into inbuf
std::copy(i, i + available_input, inbuf);
i += available_input;
// encode inbuf to outbuf
outbuf[0] = (inbuf[0] & 0xf8) >> 3;
outbuf[1] = ((inbuf[0] & 0x07) << 2) | ((inbuf[1] & 0xc0) >> 6);
outbuf[2] = ((inbuf[1] & 0x3e) >> 1);
outbuf[3] = ((inbuf[1] & 0x01) << 4) | ((inbuf[2] & 0xf0) >> 4);
outbuf[4] = ((inbuf[2] & 0x0f) << 1) | ((inbuf[3] & 0x80) >> 7);
outbuf[5] = ((inbuf[3] & 0x7c) >> 2);
outbuf[6] = ((inbuf[3] & 0x03) << 3) | ((inbuf[4] & 0xe0) >> 5);
outbuf[7] = inbuf[4] & 0x1f;
// write output
int num_out = input_output_mapping[available_input];
for (int j = 0; j < num_out; ++j)
{
ret += base32_table[outbuf[j]];
}
// write pad
for (int j = 0; j < 8 - num_out; ++j)
{
ret += '=';
}
}
return ret;
}
std::string base32decode(std::string const& s)
{
unsigned char inbuf[8];
unsigned char outbuf[5];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
int available_input = (std::min)(8, (int)std::distance(i, s.end()));
int pad_start = 0;
if (available_input < 8) pad_start = available_input;
// clear input buffer
std::fill(inbuf, inbuf+8, 0);
for (int j = 0; j < available_input; ++j)
{
char in = std::toupper(*i++);
if (in >= 'A' && in <= 'Z')
inbuf[j] = in - 'A';
else if (in >= '2' && in <= '7')
inbuf[j] = in - '2' + ('Z' - 'A') + 1;
else if (in == '=')
{
inbuf[j] = 0;
if (pad_start == 0) pad_start = j;
}
else if (in == '1')
inbuf[j] = 'I' - 'A';
else
return std::string();
TORRENT_ASSERT(inbuf[j] == (inbuf[j] & 0x1f));
}
// decode inbuf to outbuf
outbuf[0] = inbuf[0] << 3;
outbuf[0] |= inbuf[1] >> 2;
outbuf[1] = (inbuf[1] & 0x3) << 6;
outbuf[1] |= inbuf[2] << 1;
outbuf[1] |= (inbuf[3] & 0x10) >> 4;
outbuf[2] = (inbuf[3] & 0x0f) << 4;
outbuf[2] |= (inbuf[4] & 0x1e) >> 1;
outbuf[3] = (inbuf[4] & 0x01) << 7;
outbuf[3] |= (inbuf[5] & 0x1f) << 2;
outbuf[3] |= (inbuf[6] & 0x18) >> 3;
outbuf[4] = (inbuf[6] & 0x07) << 5;
outbuf[4] |= inbuf[7];
int input_output_mapping[] = {5, 1, 1, 2, 2, 3, 4, 4, 5};
int num_out = input_output_mapping[pad_start];
// write output
std::copy(outbuf, outbuf + num_out, std::back_inserter(ret));
}
return ret;
}
boost::optional<std::string> url_has_argument(
std::string const& url, std::string argument)
{
size_t i = url.find('?');
if (i == std::string::npos) return boost::optional<std::string>();
++i;
argument += '=';
if (url.compare(i, argument.size(), argument) == 0)
{
size_t pos = i + argument.size();
return url.substr(pos, url.find('&', pos) - pos);
}
argument.insert(0, "&");
i = url.find(argument, i);
if (i == std::string::npos) return boost::optional<std::string>();
size_t pos = i + argument.size();
return url.substr(pos, url.find('&', pos) - pos);
}
TORRENT_EXPORT std::string to_hex(std::string const& s)
{
std::string ret;
char const* digits = "0123456789abcdef";
for (std::string::const_iterator i = s.begin(); i != s.end(); ++i)
{
ret += digits[((unsigned char)*i) >> 4];
ret += digits[((unsigned char)*i) & 0xf];
}
return ret;
}
}
<|endoftext|> |
<commit_before>/*
event_counter.cpp
Classic Invaders
Copyright (c) 2013, Todd Steinackle, Simon Que
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.
* 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.
* Neither the name of The No Quarter Arcade (http://www.noquarterarcade.com/) 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#include "event_counter.h"
void EventCounter::report()
{
if (num_loops == 0)
return;
printf("Per-loop stats, averaged over %d loops:\n", num_loops);
printf("- Collision checks: %d\n", num_collision_checks / num_loops);
printf("- Movement calls: %d\n", num_movement_calls / num_loops);
printf("- Loop time in ticks: %d\n",
(latest_time - game_loop_start_time) / num_loops);
uint32_t total_game_logic_time = 0;
for (int i = 0; i < MAX_GAME_LOGIC_SECTIONS; ++i) {
if (game_logic_times[i] == 0)
continue;
printf("- Game logic section %d, time in ticks: %d\n", i,
game_logic_times[i] / num_loops);
total_game_logic_time += game_logic_times[i];
}
printf("- Total game logic time in ticks: %d\n",
total_game_logic_time / num_loops);
}
<commit_msg>Event counter: print info more compactly<commit_after>/*
event_counter.cpp
Classic Invaders
Copyright (c) 2013, Todd Steinackle, Simon Que
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions
and the following disclaimer.
* 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.
* Neither the name of The No Quarter Arcade (http://www.noquarterarcade.com/) 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 COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
*/
#include "event_counter.h"
void EventCounter::report()
{
if (num_loops == 0)
return;
printf("Per-loop stats, averaged over %d loops:\n", num_loops);
printf("- Collision checks: %d\n", num_collision_checks / num_loops);
printf("- Movement calls: %d\n", num_movement_calls / num_loops);
printf("- Loop time in ticks: %d\n",
(latest_time - game_loop_start_time) / num_loops);
uint32_t total_game_logic_time = 0;
printf("- Per-section game logic times: ");
for (int i = 0; i < MAX_GAME_LOGIC_SECTIONS; ++i) {
total_game_logic_time += game_logic_times[i];
if (game_logic_times[i] >= num_loops)
printf("%lu ", game_logic_times[i] / num_loops);
else // If the rounded-down value is zero, don't bother printing it.
printf("_ "); // Just print a placeholder.
}
printf("\n");
printf("- Total game logic time in ticks: %d\n",
total_game_logic_time / num_loops);
}
<|endoftext|> |
<commit_before><commit_msg>change transformation matrix<commit_after><|endoftext|> |
<commit_before><commit_msg>planning: add CROSSWALK tag to learning data<commit_after><|endoftext|> |
<commit_before>/*********************************************************************************
*
* Inviwo - Interactive Visualization Workshop
*
* Copyright (c) 2016-2017 Inviwo Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
*
*********************************************************************************/
#include <modules/postprocessing/processors/hdrbloom.h>
#include <modules/opengl/image/imagegl.h>
#include <modules/opengl/texture/textureutils.h>
#include <modules/opengl/openglutils.h>
#include <modules/opengl/sharedopenglresources.h>
#include <modules/opengl/geometry/meshgl.h>
#include <random>
namespace inviwo {
// The Class Identifier has to be globally unique. Use a reverse DNS naming scheme
const ProcessorInfo HdrBloom::processorInfo_{
"org.inviwo.HdrBloom", // Class identifier
"HDR Bloom", // Display name
"Postprocessing", // Category
CodeState::Stable, // Code state
Tags::GL, // Tags
};
const ProcessorInfo HdrBloom::getProcessorInfo() const { return processorInfo_; }
HdrBloom::HdrBloom()
: Processor()
, inport_("inport")
, outport_("outport")
, enable_("enable", "Enable Operation", true)
, threshold_("threshold", "Threshold", 1.f, 0.f, 10.f)
, strength_("strength", "Strength", 1.f, 0.f, 3.f)
, radius_("radius", "Radius", 0.5f, 0.f, 1.f)
, highPass_("fullscreenquad.vert", "bloomhighpass.frag")
, blur_("fullscreenquad.vert", "bloomblur.frag")
, compose_("fullscreenquad.vert", "bloomcompose.frag")
, width_(0)
, height_(0)
, texBright_(size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR) {
addPort(inport_);
addPort(outport_);
addProperty(enable_);
addProperty(threshold_);
addProperty(strength_);
addProperty(radius_);
for (int i = 0; i < Levels; i++) {
texHorizontal_[i] = std::make_unique<Texture2D>(
size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR);
texVertical_[i] = std::make_unique<Texture2D>(
size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR);
fboHorizontal_[i].activate();
fboHorizontal_[i].attachColorTexture(texHorizontal_[i].get());
fboVertical_[i].activate();
fboVertical_[i].attachColorTexture(texVertical_[i].get());
}
fboBright_.activate();
fboBright_.attachColorTexture(&texBright_);
FrameBufferObject::deactivateFBO();
inport_.onChange([this]() {
const DataFormatBase* format = inport_.getData()->getDataFormat();
const auto swizzleMask = inport_.getData()->getColorLayer()->getSwizzleMask();
if (!outport_.hasEditableData() || format != outport_.getData()->getDataFormat() ||
swizzleMask != outport_.getData()->getColorLayer()->getSwizzleMask()) {
auto dim = outport_.getData()->getDimensions();
Image* img = new Image(dim, format);
img->copyMetaDataFrom(*inport_.getData());
// forward swizzle mask of the input
img->getColorLayer()->setSwizzleMask(swizzleMask);
outport_.setData(img);
}
});
}
HdrBloom::~HdrBloom() {}
void HdrBloom::process() {
if (!enable_.get()) {
outport_.setData(inport_.getData());
return;
}
const int width = static_cast<int>(outport_.getDimensions().x);
const int height = static_cast<int>(outport_.getDimensions().y);
if (width != width_ || height != height_) {
resizeTextures(width, height);
}
// Copy color, depth and picking
utilgl::activateTargetAndCopySource(outport_, inport_);
auto imageGL = inport_.getData()->getRepresentation<ImageGL>();
auto colorLayer = imageGL->getColorLayerGL();
auto colorTex = colorLayer->getTexture()->getID();
// This geometry is actually never used in the shader
auto rect = SharedOpenGLResources::getPtr()->imagePlaneRect();
utilgl::Enable<MeshGL> enable(rect);
utilgl::GlBoolState depth(GL_DEPTH_TEST, false);
glActiveTexture(GL_TEXTURE0);
// --- HIGHPASS ---
fboBright_.activate();
utilgl::ViewportState(ivec4(0, 0, texBright_.getWidth(), texBright_.getHeight()));
glBindTexture(GL_TEXTURE_2D, colorTex);
highPass_.activate();
highPass_.setUniform("threshold", threshold_.get());
highPass_.setUniform("texSource", 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
// --- BLUR ---
Texture2D* input_tex = &texBright_;
blur_.activate();
blur_.setUniform("texSource", 0);
for (int i = 0; i < Levels; i++) {
auto inv_res = 1.f / vec2(input_tex->getWidth(), input_tex->getHeight());
glViewport(0, 0, static_cast<GLsizei>(texHorizontal_[i]->getWidth()),
static_cast<GLsizei>(texHorizontal_[i]->getHeight()));
// --- X-PASS ---
input_tex->bind();
fboHorizontal_[i].activate();
blur_.setUniform("direction", vec2(1, 0) * inv_res);
glDrawArrays(GL_TRIANGLES, 0, 3);
// --- Y-PASS ---
texHorizontal_[i]->bind();
fboVertical_[i].activate();
blur_.setUniform("direction", vec2(0, 1) * inv_res);
glDrawArrays(GL_TRIANGLES, 0, 3);
input_tex = texVertical_[i].get();
}
// --- COMPOSE ---
utilgl::activateTarget(outport_, ImageType::ColorOnly);
compose_.activate();
// Blend bloom results onto colorchannel of outport.
utilgl::GlBoolState blend(GL_BLEND, true);
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
std::array<float, Levels> factors{1.0f, 0.8f, 0.6f, 0.4f, 0.2f};
compose_.setUniform("bloomStrength", strength_.get());
compose_.setUniform("bloomRadius", radius_.get());
for (int i = 0; i < Levels; i++) {
glActiveTexture(GL_TEXTURE0 + i);
texVertical_[i]->bind();
compose_.setUniform("tex" + std::to_string(i), i);
}
glDrawArrays(GL_TRIANGLES, 0, 3);
glBlendEquation(GL_FUNC_ADD);
compose_.deactivate();
glBindTexture(GL_TEXTURE_2D, 0);
}
void HdrBloom::resizeTextures(int width, int height) {
int res_x = width / 2;
int res_y = height / 2;
texBright_.resize(size2_t(width, height));
for (int i = 0; i < Levels; i++) {
texHorizontal_[i]->resize(size2_t(res_x, res_y));
texVertical_[i]->resize(size2_t(res_x, res_y));
res_x /= 2;
res_y /= 2;
}
width_ = width;
height_ = height;
}
} // namespace inviwo
<commit_msg>ProstProcessing: Removed unused variable<commit_after>/*********************************************************************************
*
* Inviwo - Interactive Visualization Workshop
*
* Copyright (c) 2016-2017 Inviwo Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
*
*********************************************************************************/
#include <modules/postprocessing/processors/hdrbloom.h>
#include <modules/opengl/image/imagegl.h>
#include <modules/opengl/texture/textureutils.h>
#include <modules/opengl/openglutils.h>
#include <modules/opengl/sharedopenglresources.h>
#include <modules/opengl/geometry/meshgl.h>
#include <random>
namespace inviwo {
// The Class Identifier has to be globally unique. Use a reverse DNS naming scheme
const ProcessorInfo HdrBloom::processorInfo_{
"org.inviwo.HdrBloom", // Class identifier
"HDR Bloom", // Display name
"Postprocessing", // Category
CodeState::Stable, // Code state
Tags::GL, // Tags
};
const ProcessorInfo HdrBloom::getProcessorInfo() const { return processorInfo_; }
HdrBloom::HdrBloom()
: Processor()
, inport_("inport")
, outport_("outport")
, enable_("enable", "Enable Operation", true)
, threshold_("threshold", "Threshold", 1.f, 0.f, 10.f)
, strength_("strength", "Strength", 1.f, 0.f, 3.f)
, radius_("radius", "Radius", 0.5f, 0.f, 1.f)
, highPass_("fullscreenquad.vert", "bloomhighpass.frag")
, blur_("fullscreenquad.vert", "bloomblur.frag")
, compose_("fullscreenquad.vert", "bloomcompose.frag")
, width_(0)
, height_(0)
, texBright_(size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR) {
addPort(inport_);
addPort(outport_);
addProperty(enable_);
addProperty(threshold_);
addProperty(strength_);
addProperty(radius_);
for (int i = 0; i < Levels; i++) {
texHorizontal_[i] = std::make_unique<Texture2D>(
size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR);
texVertical_[i] = std::make_unique<Texture2D>(
size2_t(256, 256), GLFormats::get(DataFormatId::Vec4Float16), GL_LINEAR);
fboHorizontal_[i].activate();
fboHorizontal_[i].attachColorTexture(texHorizontal_[i].get());
fboVertical_[i].activate();
fboVertical_[i].attachColorTexture(texVertical_[i].get());
}
fboBright_.activate();
fboBright_.attachColorTexture(&texBright_);
FrameBufferObject::deactivateFBO();
inport_.onChange([this]() {
const DataFormatBase* format = inport_.getData()->getDataFormat();
const auto swizzleMask = inport_.getData()->getColorLayer()->getSwizzleMask();
if (!outport_.hasEditableData() || format != outport_.getData()->getDataFormat() ||
swizzleMask != outport_.getData()->getColorLayer()->getSwizzleMask()) {
auto dim = outport_.getData()->getDimensions();
Image* img = new Image(dim, format);
img->copyMetaDataFrom(*inport_.getData());
// forward swizzle mask of the input
img->getColorLayer()->setSwizzleMask(swizzleMask);
outport_.setData(img);
}
});
}
HdrBloom::~HdrBloom() {}
void HdrBloom::process() {
if (!enable_.get()) {
outport_.setData(inport_.getData());
return;
}
const int width = static_cast<int>(outport_.getDimensions().x);
const int height = static_cast<int>(outport_.getDimensions().y);
if (width != width_ || height != height_) {
resizeTextures(width, height);
}
// Copy color, depth and picking
utilgl::activateTargetAndCopySource(outport_, inport_);
auto imageGL = inport_.getData()->getRepresentation<ImageGL>();
auto colorLayer = imageGL->getColorLayerGL();
auto colorTex = colorLayer->getTexture()->getID();
// This geometry is actually never used in the shader
auto rect = SharedOpenGLResources::getPtr()->imagePlaneRect();
utilgl::Enable<MeshGL> enable(rect);
utilgl::GlBoolState depth(GL_DEPTH_TEST, false);
glActiveTexture(GL_TEXTURE0);
// --- HIGHPASS ---
fboBright_.activate();
utilgl::ViewportState(ivec4(0, 0, texBright_.getWidth(), texBright_.getHeight()));
glBindTexture(GL_TEXTURE_2D, colorTex);
highPass_.activate();
highPass_.setUniform("threshold", threshold_.get());
highPass_.setUniform("texSource", 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
// --- BLUR ---
Texture2D* input_tex = &texBright_;
blur_.activate();
blur_.setUniform("texSource", 0);
for (int i = 0; i < Levels; i++) {
auto inv_res = 1.f / vec2(input_tex->getWidth(), input_tex->getHeight());
glViewport(0, 0, static_cast<GLsizei>(texHorizontal_[i]->getWidth()),
static_cast<GLsizei>(texHorizontal_[i]->getHeight()));
// --- X-PASS ---
input_tex->bind();
fboHorizontal_[i].activate();
blur_.setUniform("direction", vec2(1, 0) * inv_res);
glDrawArrays(GL_TRIANGLES, 0, 3);
// --- Y-PASS ---
texHorizontal_[i]->bind();
fboVertical_[i].activate();
blur_.setUniform("direction", vec2(0, 1) * inv_res);
glDrawArrays(GL_TRIANGLES, 0, 3);
input_tex = texVertical_[i].get();
}
// --- COMPOSE ---
utilgl::activateTarget(outport_, ImageType::ColorOnly);
compose_.activate();
// Blend bloom results onto colorchannel of outport.
utilgl::GlBoolState blend(GL_BLEND, true);
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
compose_.setUniform("bloomStrength", strength_.get());
compose_.setUniform("bloomRadius", radius_.get());
for (int i = 0; i < Levels; i++) {
glActiveTexture(GL_TEXTURE0 + i);
texVertical_[i]->bind();
compose_.setUniform("tex" + std::to_string(i), i);
}
glDrawArrays(GL_TRIANGLES, 0, 3);
glBlendEquation(GL_FUNC_ADD);
compose_.deactivate();
glBindTexture(GL_TEXTURE_2D, 0);
}
void HdrBloom::resizeTextures(int width, int height) {
int res_x = width / 2;
int res_y = height / 2;
texBright_.resize(size2_t(width, height));
for (int i = 0; i < Levels; i++) {
texHorizontal_[i]->resize(size2_t(res_x, res_y));
texVertical_[i]->resize(size2_t(res_x, res_y));
res_x /= 2;
res_y /= 2;
}
width_ = width;
height_ = height;
}
} // namespace inviwo
<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.