text:
package query

//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/query.json build_test.go

import (
	"net/url"

	"github.com/aws/aws-sdk-go/aws/awserr"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
)

// Build builds a request for an AWS Query service.
func Build(r *request.Request) {
	body := url.Values{
		"Action":  {r.Operation.Name},
		"Version": {r.Service.APIVersion},
	}
	if err := queryutil.Parse(body, r.Params, false); err != nil {
		r.Error = awserr.New("SerializationError", "failed encoding Query request", err)
		return
	}

	if r.ExpireTime == 0 {
		r.HTTPRequest.Method = "POST"
		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
		r.SetBufferBody([]byte(body.Encode()))
	} else { // This is a pre-signed request
		r.HTTPRequest.Method = "GET"
		r.HTTPRequest.URL.RawQuery = body.Encode()
	}
}


text:
/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkObjectWrap.h"
#include "vtkGenericSubdivisionErrorMetricWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkGenericAdaptorCellWrap.h"
#include "vtkGenericDataSetWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkGenericSubdivisionErrorMetricWrap::ptpl;

VtkGenericSubdivisionErrorMetricWrap::VtkGenericSubdivisionErrorMetricWrap()
{ }

VtkGenericSubdivisionErrorMetricWrap::VtkGenericSubdivisionErrorMetricWrap(vtkSmartPointer<vtkGenericSubdivisionErrorMetric> _native)
{ native = _native; }

VtkGenericSubdivisionErrorMetricWrap::~VtkGenericSubdivisionErrorMetricWrap()
{ }

void VtkGenericSubdivisionErrorMetricWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkGenericSubdivisionErrorMetric").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("GenericSubdivisionErrorMetric").ToLocalChecked(), ConstructorGetter);
}

void VtkGenericSubdivisionErrorMetricWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkGenericSubdivisionErrorMetricWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkObjectWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkObjectWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkGenericSubdivisionErrorMetricWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "GetDataSet", GetDataSet);
	Nan::SetPrototypeMethod(tpl, "getDataSet", GetDataSet);

	Nan::SetPrototypeMethod(tpl, "GetGenericCell", GetGenericCell);
	Nan::SetPrototypeMethod(tpl, "getGenericCell", GetGenericCell);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetDataSet", SetDataSet);
	Nan::SetPrototypeMethod(tpl, "setDataSet", SetDataSet);

	Nan::SetPrototypeMethod(tpl, "SetGenericCell", SetGenericCell);
	Nan::SetPrototypeMethod(tpl, "setGenericCell", SetGenericCell);

#ifdef VTK_NODE_PLUS_VTKGENERICSUBDIVISIONERRORMETRICWRAP_INITPTPL
	VTK_NODE_PLUS_VTKGENERICSUBDIVISIONERRORMETRICWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkGenericSubdivisionErrorMetricWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		Nan::ThrowError("Cannot create instance of abstract class.");
		return;
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkGenericSubdivisionErrorMetricWrap::GetDataSet(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	vtkGenericDataSet * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetDataSet();
	VtkGenericDataSetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkGenericDataSetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkGenericDataSetWrap *w = new VtkGenericDataSetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkGenericSubdivisionErrorMetricWrap::GetGenericCell(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	vtkGenericAdaptorCell * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGenericCell();
	VtkGenericAdaptorCellWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkGenericAdaptorCellWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkGenericAdaptorCellWrap *w = new VtkGenericAdaptorCellWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkGenericSubdivisionErrorMetricWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	vtkGenericSubdivisionErrorMetric * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkGenericSubdivisionErrorMetricWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkGenericSubdivisionErrorMetricWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkGenericSubdivisionErrorMetricWrap *w = new VtkGenericSubdivisionErrorMetricWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkGenericSubdivisionErrorMetricWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectBaseWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectBaseWrap *a0 = ObjectWrap::Unwrap<VtkObjectBaseWrap>(info[0]->ToObject());
		vtkGenericSubdivisionErrorMetric * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObjectBase *) a0->native.GetPointer()
		);
		VtkGenericSubdivisionErrorMetricWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkGenericSubdivisionErrorMetricWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkGenericSubdivisionErrorMetricWrap *w = new VtkGenericSubdivisionErrorMetricWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkGenericSubdivisionErrorMetricWrap::SetDataSet(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkGenericDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkGenericDataSetWrap *a0 = ObjectWrap::Unwrap<VtkGenericDataSetWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetDataSet(
			(vtkGenericDataSet *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkGenericSubdivisionErrorMetricWrap::SetGenericCell(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkGenericSubdivisionErrorMetricWrap *wrapper = ObjectWrap::Unwrap<VtkGenericSubdivisionErrorMetricWrap>(info.Holder());
	vtkGenericSubdivisionErrorMetric *native = (vtkGenericSubdivisionErrorMetric *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkGenericAdaptorCellWrap::ptpl))->HasInstance(info[0]))
	{
		VtkGenericAdaptorCellWrap *a0 = ObjectWrap::Unwrap<VtkGenericAdaptorCellWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGenericCell(
			(vtkGenericAdaptorCell *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

redpajama_set_name: RedPajamaGithub


text:
/* Includes ------------------------------------------------------------------*/
#include "lwip/opt.h"
#include "stm32f429_eth.h"
#include "LAN8742A.h"
#include "lwip/netif.h"
#include "netconf.h"
#include "lwip/dhcp.h"
#include "lwip/mem.h"
#include "lwip/memp.h"
#include "lwip/tcp.h"
#include "lwip/udp.h"
#include "netif/etharp.h"
#include "lwip/tcpip.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
ETH_InitTypeDef ETH_InitStructure;
__IO uint32_t  EthStatus = 0;
__IO uint8_t EthLinkStatus = 0;
extern struct netif gnetif;
#ifdef USE_DHCP
extern __IO uint8_t DHCP_state;
#endif /* LWIP_DHCP */

/* Private function prototypes -----------------------------------------------*/
static void ETH_GPIO_Config(void);
static void ETH_MACDMA_Config(void);

/* Private functions ---------------------------------------------------------*/
/* Bit 2 from Basic Status Register in PHY */
#define GET_PHY_LINK_STATUS()		(ETH_ReadPHYRegister(ETHERNET_PHY_ADDRESS, PHY_BSR) & 0x00000004)

/**
  * @brief  ETH_BSP_Config
  * @param  None
  * @retval None
  */
uint8_t ETH_BSP_Config(void)
{
  /* Configure the GPIO ports for ethernet pins */
  ETH_GPIO_Config();

  /* Configure the Ethernet MAC/DMA */
  ETH_MACDMA_Config();
  /* Get Ethernet link status*/
  if(GET_PHY_LINK_STATUS())
  {
    EthStatus |= ETH_LINK_FLAG;
    return 0;
  }
  return 1;
}

/**
  * @brief  Configures the Ethernet Interface
  * @param  None
  * @retval None
  */
static void ETH_MACDMA_Config(void)
{
  /* Enable ETHERNET clock  */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_ETH_MAC | RCC_AHB1Periph_ETH_MAC_Tx |
                        RCC_AHB1Periph_ETH_MAC_Rx, ENABLE);

  /* Reset ETHERNET on AHB Bus */
  ETH_DeInit();

  /* Software reset */
  ETH_SoftwareReset();

  /* Wait for software reset */
  while (ETH_GetSoftwareResetStatus() == SET);

  /* ETHERNET Configuration --------------------------------------------------*/
  /* Call ETH_StructInit if you don't like to configure all ETH_InitStructure parameter */
  ETH_StructInit(&ETH_InitStructure);

  /* Fill ETH_InitStructure parametrs */
  /*------------------------   MAC   -----------------------------------*/
	/* ¿ªÆôÍøÂç×ÔÊÊÓ¦¹¦ÄÜ */
  ETH_InitStructure.ETH_AutoNegotiation = ETH_AutoNegotiation_Enable;
//  ETH_InitStructure.ETH_AutoNegotiation = ETH_AutoNegotiation_Disable;
//  ETH_InitStructure.ETH_Speed = ETH_Speed_10M;
//  ETH_InitStructure.ETH_Mode = ETH_Mode_FullDuplex;
  /* ¹Ø±Õ·´À¡ */
  ETH_InitStructure.ETH_LoopbackMode = ETH_LoopbackMode_Disable;
	/* ¹Ø±ÕÖØ´«¹¦ÄÜ */
  ETH_InitStructure.ETH_RetryTransmission = ETH_RetryTransmission_Disable;
	/* ¹Ø±Õ×Ô¶¯È¥³ýPDA/CRC¹¦ÄÜ  */
  ETH_InitStructure.ETH_AutomaticPadCRCStrip = ETH_AutomaticPadCRCStrip_Disable;
	/* ¹Ø±Õ½ÓÊÕËùÓеÄÖ¡ */
  ETH_InitStructure.ETH_ReceiveAll = ETH_ReceiveAll_Disable;
	/* ÔÊÐí½ÓÊÕËùÓй㲥֡ */
  ETH_InitStructure.ETH_BroadcastFramesReception = ETH_BroadcastFramesReception_Enable;
	/* ¹Ø±Õ»ìºÏģʽµÄµØÖ·¹ýÂË  */
  ETH_InitStructure.ETH_PromiscuousMode = ETH_PromiscuousMode_Disable;
	/* ¶ÔÓÚ×é²¥µØַʹÓÃÍêÃÀµØÖ·¹ýÂË    */
  ETH_InitStructure.ETH_MulticastFramesFilter = ETH_MulticastFramesFilter_Perfect;
	/* ¶Ôµ¥²¥µØַʹÓÃÍêÃÀµØÖ·¹ýÂË  */
  ETH_InitStructure.ETH_UnicastFramesFilter = ETH_UnicastFramesFilter_Perfect;
#ifdef CHECKSUM_BY_HARDWARE
	/* ¿ªÆôipv4ºÍTCP/UDP/ICMPµÄ֡УÑéºÍжÔØ   */
  ETH_InitStructure.ETH_ChecksumOffload = ETH_ChecksumOffload_Enable;
#endif

  /*------------------------   DMA   -----------------------------------*/

  /* When we use the Checksum offload feature, we need to enable the Store and Forward mode:
  the store and forward guarantee that a whole frame is stored in the FIFO, so the MAC can insert/verify the checksum,
  if the checksum is OK the DMA can handle the frame otherwise the frame is dropped */
	/*µ±ÎÒÃÇʹÓÃ֡УÑéºÍжÔع¦ÄܵÄʱºò£¬Ò»¶¨ÒªÊ¹Äܴ洢ת·¢Ä£Ê½,´æ´¢×ª·¢Ä£Ê½ÖÐÒª±£Ö¤Õû¸öÖ¡´æ´¢ÔÚFIFOÖÐ,
	ÕâÑùMACÄܲåÈë/ʶ±ð³ö֡УÑéÖµ,µ±ÕæУÑéÕýÈ·µÄʱºòDMA¾Í¿ÉÒÔ´¦ÀíÖ¡,·ñÔò¾Í¶ªÆúµô¸ÃÖ¡*/

	/* ¿ªÆô¶ªÆúTCP/IP´íÎóÖ¡ */
  ETH_InitStructure.ETH_DropTCPIPChecksumErrorFrame = ETH_DropTCPIPChecksumErrorFrame_Enable;
	/* ¿ªÆô½ÓÊÕÊý¾ÝµÄ´æ´¢×ª·¢Ä£Ê½  */
  ETH_InitStructure.ETH_ReceiveStoreForward = ETH_ReceiveStoreForward_Enable;
	/* ¿ªÆô·¢ËÍÊý¾ÝµÄ´æ´¢×ª·¢Ä£Ê½   */
  ETH_InitStructure.ETH_TransmitStoreForward = ETH_TransmitStoreForward_Enable;

	/* ½ûֹת·¢´íÎóÖ¡ */
  ETH_InitStructure.ETH_ForwardErrorFrames = ETH_ForwardErrorFrames_Disable;
	/* ²»×ª·¢¹ýСµÄºÃÖ¡ */
  ETH_InitStructure.ETH_ForwardUndersizedGoodFrames = ETH_ForwardUndersizedGoodFrames_Disable;
	/* ´ò¿ª´¦ÀíµÚ¶þÖ¡¹¦ÄÜ */
  ETH_InitStructure.ETH_SecondFrameOperate = ETH_SecondFrameOperate_Enable;
	/* ¿ªÆôDMA´«ÊäµÄµØÖ·¶ÔÆ빦ÄÜ */
  ETH_InitStructure.ETH_AddressAlignedBeats = ETH_AddressAlignedBeats_Enable;
	/* ¿ªÆô¹Ì¶¨Í»·¢¹¦ÄÜ */
  ETH_InitStructure.ETH_FixedBurst = ETH_FixedBurst_Enable;
	/* DMA·¢Ë͵Ä×î´óÍ»·¢³¤¶ÈΪ32¸ö½ÚÅÄ */
  ETH_InitStructure.ETH_RxDMABurstLength = ETH_RxDMABurstLength_32Beat;
	/*DMA½ÓÊÕµÄ×î´óÍ»·¢³¤¶ÈΪ32¸ö½ÚÅÄ */
  ETH_InitStructure.ETH_TxDMABurstLength = ETH_TxDMABurstLength_32Beat;
  ETH_InitStructure.ETH_DMAArbitration = ETH_DMAArbitration_RoundRobin_RxTx_2_1;

  /* Configure Ethernet */
	/* ÅäÖÃETH */
  EthStatus = ETH_Init(&ETH_InitStructure, ETHERNET_PHY_ADDRESS);
}

/**
  * @brief  Configures the different GPIO ports.
  * @param  None
  * @retval None
  */
void ETH_GPIO_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

/* Enable GPIOs clocks */
  RCC_AHB1PeriphClockCmd(ETH_MDIO_GPIO_CLK            | ETH_MDC_GPIO_CLK          |
                         ETH_RMII_REF_CLK_GPIO_CLK    | ETH_RMII_CRS_DV_GPIO_CLK  |
                         ETH_RMII_RXD0_GPIO_CLK       | ETH_RMII_RXD1_GPIO_CLK    |
                         ETH_RMII_TX_EN_GPIO_CLK      | ETH_RMII_TXD0_GPIO_CLK    |
                         ETH_RMII_TXD1_GPIO_CLK       | ETH_NRST_GPIO_CLK         , ENABLE);

  /* Enable SYSCFG clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

  /* MII/RMII Media interface selection --------------------------------------*/
#ifdef MII_MODE /* Mode MII with STM324xG-EVAL  */
 #ifdef PHY_CLOCK_MCO

  /* Output HSE clock (25MHz) on MCO pin (PA8) to clock the PHY */
  RCC_MCO1Config(RCC_MCO1Source_HSE, RCC_MCO1Div_1);
 #endif /* PHY_CLOCK_MCO */

  SYSCFG_ETH_MediaInterfaceConfig(SYSCFG_ETH_MediaInterface_MII);
#elif defined RMII_MODE  /* Mode RMII with STM324xG-EVAL */

  SYSCFG_ETH_MediaInterfaceConfig(SYSCFG_ETH_MediaInterface_RMII);
#endif

/* Ethernet pins configuration ************************************************/
   /*
        ETH_MDIO -------------------------> PA2
        ETH_MDC --------------------------> PC1
        ETH_MII_RX_CLK/ETH_RMII_REF_CLK---> PA1
        ETH_MII_RX_DV/ETH_RMII_CRS_DV ----> PA7
        ETH_MII_RXD0/ETH_RMII_RXD0 -------> PC4
        ETH_MII_RXD1/ETH_RMII_RXD1 -------> PC5
        ETH_MII_TX_EN/ETH_RMII_TX_EN -----> PB11
        ETH_MII_TXD0/ETH_RMII_TXD0 -------> PG13
        ETH_MII_TXD1/ETH_RMII_TXD1 -------> PG14
				ETH_NRST -------------------------> PI1

		*/

	GPIO_InitStructure.GPIO_Pin = ETH_NRST_PIN;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
	GPIO_Init(ETH_NRST_PORT, &GPIO_InitStructure);

	ETH_NRST_PIN_LOW();
	_eth_delay_(LAN8742A_RESET_DELAY);
	ETH_NRST_PIN_HIGH();
	_eth_delay_(LAN8742A_RESET_DELAY);

   /* Configure ETH_MDIO */
  GPIO_InitStructure.GPIO_Pin = ETH_MDIO_PIN;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(ETH_MDIO_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_MDIO_PORT, ETH_MDIO_SOURCE, ETH_MDIO_AF);

	/* Configure ETH_MDC */
  GPIO_InitStructure.GPIO_Pin = ETH_MDC_PIN;
  GPIO_Init(ETH_MDC_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_MDC_PORT, ETH_MDC_SOURCE, ETH_MDC_AF);

	/* Configure ETH_RMII_REF_CLK */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_REF_CLK_PIN;
  GPIO_Init(ETH_RMII_REF_CLK_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_REF_CLK_PORT, ETH_RMII_REF_CLK_SOURCE, ETH_RMII_REF_CLK_AF);

	/* Configure ETH_RMII_CRS_DV */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_CRS_DV_PIN;
  GPIO_Init(ETH_RMII_CRS_DV_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_CRS_DV_PORT, ETH_RMII_CRS_DV_SOURCE, ETH_RMII_CRS_DV_AF);

	/* Configure ETH_RMII_RXD0 */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_RXD0_PIN;
  GPIO_Init(ETH_RMII_RXD0_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_RXD0_PORT, ETH_RMII_RXD0_SOURCE, ETH_RMII_RXD0_AF);

	/* Configure ETH_RMII_RXD1 */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_RXD1_PIN;
  GPIO_Init(ETH_RMII_RXD1_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_RXD1_PORT, ETH_RMII_RXD1_SOURCE, ETH_RMII_RXD1_AF);

	/* Configure ETH_RMII_TX_EN */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_TX_EN_PIN;
  GPIO_Init(ETH_RMII_TX_EN_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_TX_EN_PORT, ETH_RMII_TX_EN_SOURCE, ETH_RMII_TX_EN_AF);

	/* Configure ETH_RMII_TXD0 */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_TXD0_PIN;
  GPIO_Init(ETH_RMII_TXD0_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_TXD0_PORT, ETH_RMII_TXD0_SOURCE, ETH_RMII_TXD0_AF);

	/* Configure ETH_RMII_TXD1 */
  GPIO_InitStructure.GPIO_Pin = ETH_RMII_TXD1_PIN;
  GPIO_Init(ETH_RMII_TXD1_PORT, &GPIO_InitStructure);
  GPIO_PinAFConfig(ETH_RMII_TXD1_PORT, ETH_RMII_TXD1_SOURCE, ETH_RMII_TXD1_AF);
}

/* This function is called periodically each second */
/* It checks link status for ethernet controller */
void ETH_CheckLinkStatus(uint16_t PHYAddress)
{
	static uint8_t status = 0;
	uint32_t t = GET_PHY_LINK_STATUS();

	/* If we have link and previous check was not yet */
	if (t && !status) {
		/* Set link up */
		netif_set_link_up(&gnetif);

		status = 1;
	}
	/* If we don't have link and it was on previous check */
	if (!t && status) {
		EthLinkStatus = 1;
		/* Set link down */
		netif_set_link_down(&gnetif);

		status = 0;
	}
}

#if 0
/**
  * @brief  Link callback function, this function is called on change of link status.
  * @param  The network interface
  * @retval None
  */
void ETH_link_callback(struct netif *netif)
{
  volatile uint32_t timeout = 0;
  uint32_t tmpreg,RegValue;
  ip_addr_t ipaddr;
  ip_addr_t netmask;
  ip_addr_t gw;

  if(netif_is_link_up(netif))
  {
    /* Restart the autonegotiation */
    if(ETH_InitStructure.ETH_AutoNegotiation != ETH_AutoNegotiation_Disable)
    {
      /* Reset Timeout counter */
      timeout = 0;

      /* Enable auto-negotiation */
      ETH_WritePHYRegister(ETHERNET_PHY_ADDRESS, PHY_BCR, PHY_AutoNegotiation);

      /* Wait until the auto-negotiation will be completed */
      do
      {
        timeout++;
      } while (!(ETH_ReadPHYRegister(ETHERNET_PHY_ADDRESS, PHY_BSR) & PHY_AutoNego_Complete) && (timeout < (uint32_t)PHY_READ_TO));

      /* Reset Timeout counter */
      timeout = 0;

      /* Read the result of the auto-negotiation */
      RegValue = ETH_ReadPHYRegister(ETHERNET_PHY_ADDRESS, PHY_SR);

      /* Configure the MAC with the Duplex Mode fixed by the auto-negotiation process */
      if((RegValue & PHY_DUPLEX_STATUS) != (uint32_t)RESET)
      {
        /* Set Ethernet duplex mode to Full-duplex following the auto-negotiation */
        ETH_InitStructure.ETH_Mode = ETH_Mode_FullDuplex;
      }
      else
      {
        /* Set Ethernet duplex mode to Half-duplex following the auto-negotiation */
        ETH_InitStructure.ETH_Mode = ETH_Mode_HalfDuplex;
      }
      /* Configure the MAC with the speed fixed by the auto-negotiation process */
      if(RegValue & PHY_SPEED_STATUS)
      {
        /* Set Ethernet speed to 10M following the auto-negotiation */
        ETH_InitStructure.ETH_Speed = ETH_Speed_10M;
      }
      else
      {
        /* Set Ethernet speed to 100M following the auto-negotiation */
        ETH_InitStructure.ETH_Speed = ETH_Speed_100M;
      }

//    	/* This is different for every PHY */
//			ETH_EXTERN_GetSpeedAndDuplex(ETHERNET_PHY_ADDRESS, &ETH_InitStructure);

      /*------------------------ ETHERNET MACCR Re-Configuration --------------------*/
      /* Get the ETHERNET MACCR value */
      tmpreg = ETH->MACCR;

      /* Set the FES bit according to ETH_Speed value */
      /* Set the DM bit according to ETH_Mode value */
      tmpreg |= (uint32_t)(ETH_InitStructure.ETH_Speed | ETH_InitStructure.ETH_Mode);

      /* Write to ETHERNET MACCR */
      ETH->MACCR = (uint32_t)tmpreg;

      _eth_delay_(ETH_REG_WRITE_DELAY);
      tmpreg = ETH->MACCR;
      ETH->MACCR = tmpreg;
    }

    /* Restart MAC interface */
    ETH_Start();

#ifdef USE_DHCP
    ipaddr.addr = 0;
    netmask.addr = 0;
    gw.addr = 0;
    DHCP_state = DHCP_START;
#else
    IP4_ADDR(&ipaddr, 192, 168, 1, 10);
    IP4_ADDR(&netmask, 255, 255 , 255, 255);
    IP4_ADDR(&gw, 192, 168, 1, 1);
#endif /* USE_DHCP */

    netif_set_addr(&gnetif, &ipaddr , &netmask, &gw);

    /* When the netif is fully configured this function must be called.*/
    netif_set_up(&gnetif);

    EthLinkStatus = 0;
  }
  else
  {
    ETH_Stop();
#ifdef USE_DHCP
    DHCP_state = DHCP_LINK_DOWN;
    dhcp_stop(netif);
#endif /* USE_DHCP */

    /*  When the netif link is down this function must be called.*/
    netif_set_down(&gnetif);
  }
}

#endif

void ETH_EXTERN_GetSpeedAndDuplex(uint32_t PHYAddress, ETH_InitTypeDef* ETH_InitStruct)
{
	uint32_t RegValue;

/* LAN8720A */
	/* Read status register, register number 31 = 0x1F */
	RegValue = ETH_ReadPHYRegister(ETHERNET_PHY_ADDRESS, 0x1F);
	/* Mask out bits which are not for speed and link indication, bits 4:2 are used */
	RegValue = (RegValue >> 2) & 0x07;

	/* Switch statement */
	switch (RegValue) {
		case 1: /* Base 10, half-duplex */
			ETH_InitStruct->ETH_Speed = ETH_Speed_10M;
			ETH_InitStruct->ETH_Mode = ETH_Mode_HalfDuplex;
			break;
		case 2: /* Base 100, half-duplex */
			ETH_InitStruct->ETH_Speed = ETH_Speed_100M;
			ETH_InitStruct->ETH_Mode = ETH_Mode_HalfDuplex;
			break;
		case 5: /* Base 10, full-duplex */
			ETH_InitStruct->ETH_Speed = ETH_Speed_10M;
			ETH_InitStruct->ETH_Mode = ETH_Mode_FullDuplex;
			break;
		case 6: /* Base 100, full-duplex */
			ETH_InitStruct->ETH_Speed = ETH_Speed_100M;
			ETH_InitStruct->ETH_Mode = ETH_Mode_FullDuplex;
			break;
		default:
			break;
	}
/* LAN8720A */
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


text:
'use strict';

module.exports = function (t, a) {
	var result;

	a.h1("Plain text");
	result = t(document, 'razdwa', {});
	a(result.nodeType, 3);
	a(result.data, 'razdwa');

	a.h1("Mixed");
	result = t(document, '
raz elo dwa
', {});
	a(result.nodeName, 'P');
	a(result.childNodes.length, 3);
	a(result.childNodes[0].data, 'raz ');
	a(result.childNodes[1].nodeName, 'STRONG');
	a(result.childNodes[1].firstChild.data, 'elo');
	a(result.childNodes[2].data, ' dwa');

	a.h1("Plain with variables");
	result = t(document, '
marko ${ miszel } zagalo
', { miszel: 'fura' });
	a(result.nodeName, 'P');
	a(result.childNodes.length, 3);
	a(result.childNodes[0].data, 'marko ');
	a(result.childNodes[1].data, 'fura');
	a(result.childNodes[2].data, ' zagalo');

	a.h1("Mixed with variables");
	result = t(document, '
marko marek ${ miszel } zegarek' +
		' zagalo ${ fuszka }
', {
			miszel: 'fura',
			fuszka: {
				toDOM: function (document) {
					var el = document.createElement('p');
					el.innerHTML = 'razdwa';
					return el;
				}
			}
		});
	a(result.nodeName, 'P');
	a(result.childNodes.length, 4);
	a(result.childNodes[0].data, 'marko ');
	a(result.childNodes[1].nodeName, 'STRONG');
	a(result.childNodes[1].childNodes.length, 3);
	a(result.childNodes[1].childNodes[0].data, 'marek ');
	a(result.childNodes[1].childNodes[1].data, 'fura');
	a(result.childNodes[1].childNodes[2].nodeName, 'A');
	a(result.childNodes[1].childNodes[2].childNodes.length, 1);
	a(result.childNodes[1].childNodes[2].firstChild.data, ' zegarek');
	a(result.childNodes[2].data, ' zagalo ');
	a(result.childNodes[3].nodeName, 'P');
	a(result.childNodes[3].childNodes.length, 1);
	a(result.childNodes[3].childNodes[0].data, 'razdwa');

};


text:
package com.amazonaws.util;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;

import com.amazonaws.internal.SdkFilterInputStream;

/**
 * FilterInputStream implementation that wraps an InputStream containing an XML
 * document, and removes the XML namespace attribute from the XML document.
 */
class NamespaceRemovingInputStream extends SdkFilterInputStream {

    /** look ahead buffer */
    private byte[] lookAheadData = new byte[200];

    /** Set to true once the namespace has been removed */
    private boolean hasRemovedNamespace = false;

    /**
     * Constructs a new NamespaceRemovingInputStream wrapping the specified
     * InputStream.
     *
     * @param in
     *            The InputStream containing an XML document whose XML namespace
     *            is to be removed.
     */
    public NamespaceRemovingInputStream(InputStream in) {
        // Wrap our input stream in a buffered input stream to ensure
        // that it support mark/reset
        super(new BufferedInputStream(in));
    }

    /* (non-Javadoc)
     * @see java.io.FilterInputStream#read()
     */
    @Override
    public int read() throws IOException {
        abortIfNeeded();
        int b = in.read();
        if (b == 'x' && !hasRemovedNamespace) {
            lookAheadData[0] = (byte)b;
            in.mark(lookAheadData.length);
            int bytesRead = in.read(lookAheadData, 1, lookAheadData.length - 1);
            in.reset();

            String string = new String(lookAheadData, 0, bytesRead + 1, StringUtils.UTF8);

            int numberCharsMatched = matchXmlNamespaceAttribute(string);
            if (numberCharsMatched > 0) {
                for (int i = 0; i < numberCharsMatched - 1; i++) {
                    in.read();
                }
                b = in.read();
                hasRemovedNamespace = true;
            }
        }

        return b;
    }

    /* (non-Javadoc)
     * @see java.io.FilterInputStream#read(byte[], int, int)
     */
    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        for (int i = 0; i < len; i++) {
            int j = this.read();
            if (j == -1) {
                if (i == 0) return -1;
                return i;
            }

            b[i + off] = (byte)j;
        }

        return len;
    }

    /* (non-Javadoc)
     * @see java.io.FilterInputStream#read(byte[])
     */
    @Override
    public int read(byte[] b) throws IOException {
        return this.read(b, 0, b.length);
    }

    /**
     * Checks if the string starts with a complete XML namespace attribute, and
     * if so, returns the number of characters that match.
     *
     * @param s
     *            The string to check for an XML namespace definition.
     *
     * @return -1 if no XML namespace definition was found, otherwise the length
     *         of the identified XML namespace definition.
     */
    private int matchXmlNamespaceAttribute(String s) {
        /*
         * The regex we're simulating is: "xmlns\\s*=\\s*\".+?\".*"
         */
        StringPrefixSlicer stringSlicer = new StringPrefixSlicer(s);
        if (stringSlicer.removePrefix("xmlns") == false) return -1;

        stringSlicer.removeRepeatingPrefix(" ");
        if (stringSlicer.removePrefix("=") == false) return -1;
        stringSlicer.removeRepeatingPrefix(" ");

        if (stringSlicer.removePrefix("\"") == false) return -1;
        if (stringSlicer.removePrefixEndingWith("\"") == false) return -1;

        return s.length() - stringSlicer.getString().length();
    }

    /**
     * Utility class to help test and remove specified prefixes from a string.
     */
    private static final class StringPrefixSlicer {
        private String s;

        public StringPrefixSlicer(String s) {
            this.s = s;
        }

        /**
         * @return The remaining String (minus any prefixes that have been
         *         removed).
         */
        public String getString() {
            return s;
        }

        public boolean removePrefix(String prefix) {
            if (s.startsWith(prefix) == false) return false;
            s = s.substring(prefix.length());
            return true;
        }

        public boolean removeRepeatingPrefix(String prefix) {
            if (s.startsWith(prefix) == false) return false;

            while (s.startsWith(prefix)) {
                s = s.substring(prefix.length());
            }
            return true;
        }

        public boolean removePrefixEndingWith(String marker) {
            int i = s.indexOf(marker);
            if (i < 0) return false;
            s = s.substring(i + marker.length());
            return true;
        }
    }

}


text:
package com.opengamma.engine.target.lazy;

import java.io.ObjectStreamException;
import java.io.Serializable;

import com.opengamma.engine.ComputationTargetResolver;

/**
 * Base class for lazily resolved object.
 */
/* package */abstract class LazyResolvedObject<T> implements Serializable {

  private final LazyResolveContext.AtVersionCorrection _context;
  private final T _underlying;

  protected LazyResolvedObject(final LazyResolveContext.AtVersionCorrection context, final T underlying) {
    _context = context;
    _underlying = underlying;
  }

  protected LazyResolveContext.AtVersionCorrection getLazyResolveContext() {
    return _context;
  }

  protected T getUnderlying() {
    return _underlying;
  }

  protected abstract TargetResolverObject targetResolverObject(ComputationTargetResolver.AtVersionCorrection resolver);

  protected abstract Serializable simpleObject();

  public Object writeReplace() throws ObjectStreamException {
    if (getLazyResolveContext().getTargetResolver() != null) {
      LazyResolveContext.beginWrite();
      try {
        return targetResolverObject(getLazyResolveContext().getTargetResolver());
      } finally {
        LazyResolveContext.endWrite();
      }
    }
    return simpleObject();
  }

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>factory-method</artifactId>
        <groupId>org.goldonship.java-design-patten</groupId>
        <version>1.17.04-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>static-factory</artifactId>
    <packaging>jar</packaging>

</project>


text:
if [ -x /sbin/setcap ]; then
  for file in bristol brighton bristoljackstats; do
    /sbin/setcap cap_ipc_lock,cap_sys_nice=ep usr/bin/$file
  done
fi


text:
@interface PodsDummy_Pods_WikipediaUnitTests_libextobjc : NSObject
@end
@implementation PodsDummy_Pods_WikipediaUnitTests_libextobjc
@end


text:
var Foo =
/*#__PURE__*/
function (_Bar) {
  babelHelpers.inheritsLoose(Foo, _Bar);

  function Foo() {
    var _this;

    return babelHelpers.assertThisInitialized(_this);
  }

  return Foo;
}(Bar);


text:
import { types as t } from "@babel/core";
import type { NodePath, Visitor } from "@babel/traverse";

const topicReferenceVisitor: Visitor<{
  topicReferences: NodePath<t.TopicReference>[];
  sideEffectsBeforeFirstTopicReference: boolean;
}> = {
  exit(path, state) {
    if (path.isTopicReference()) {
      state.topicReferences.push(path);
    } else {
      if (
        state.topicReferences.length === 0 &&
        !state.sideEffectsBeforeFirstTopicReference &&
        !path.isPure()
      ) {
        state.sideEffectsBeforeFirstTopicReference = true;
      }
    }
  },
  "ClassBody|Function"(_, state) {
    if (state.topicReferences.length === 0) {
      state.sideEffectsBeforeFirstTopicReference = true;
    }
  },
};

// This visitor traverses `BinaryExpression`
// and replaces any that use `|>`
// with sequence expressions containing assignment expressions
// with automatically generated variables,
// from inside to outside, from left to right.
export default {
  BinaryExpression: {
    exit(path) {
      const { scope, node } = path;

      if (node.operator !== "|>") {
        // The path node is a binary expression,
        // but it is not a pipe expression.
        return;
      }

      const pipeBodyPath = path.get("right");
      if (pipeBodyPath.node.type === "TopicReference") {
        // If the pipe body is itself a lone topic reference,
        // then replace the whole expression with its left operand.
        path.replaceWith(node.left);
        return;
      }

      const visitorState = {
        topicReferences: [],
        // pipeBodyPath might be a function, and it won't be visited by
        // topicReferenceVisitor because traverse() skips the top-level
        // node. We must handle that case here manually.
        sideEffectsBeforeFirstTopicReference: pipeBodyPath.isFunction(),
      };
      pipeBodyPath.traverse(topicReferenceVisitor, visitorState);

      if (
        visitorState.topicReferences.length === 1 &&
        (!visitorState.sideEffectsBeforeFirstTopicReference ||
          path.scope.isPure(node.left, true))
      ) {
        visitorState.topicReferences[0].replaceWith(node.left);
        path.replaceWith(node.right);
        return;
      }

      const topicVariable = scope.generateUidIdentifierBasedOnNode(node);
      scope.push({ id: topicVariable });

      // Replace topic references with the topic variable.
      visitorState.topicReferences.forEach(path =>
        path.replaceWith(t.cloneNode(topicVariable)),
      );

      // Replace the pipe expression itself with an assignment expression.
      path.replaceWith(
        t.sequenceExpression([
          t.assignmentExpression("=", t.cloneNode(topicVariable), node.left),
          node.right,
        ]),
      );
    },
  },
};


text:
package org.elasticsearch.search.aggregations.metrics;

import org.elasticsearch.search.aggregations.metrics.stats.StatsAggregationBuilder;

public class StatsTests extends AbstractNumericMetricTestCase<StatsAggregationBuilder> {

    @Override
    protected StatsAggregationBuilder doCreateTestAggregatorFactory() {
        return new StatsAggregationBuilder("foo");
    }

}


text:
namespace gfx {
struct VectorIcon;
}

namespace ash {
namespace network_icon {

// Number of images for signal strength arcs or bars for wireless networks.
constexpr int kNumNetworkImages = 5;

// 'NONE' will default to ARCS behavior where appropriate (e.g. no network).
enum ImageType { ARCS, BARS, NONE };

// Describes a single badge which is defined by a vector icon.
struct Badge {
  bool operator==(const Badge& other) const {
    return other.icon == icon && other.color == color;
  }
  bool operator!=(const Badge& other) const { return !(other == *this); }

  const gfx::VectorIcon* icon = nullptr;
  SkColor color = gfx::kPlaceholderColor;
};

// Struct to pass a collection of badges to NetworkIconImageSource.
struct Badges {
  Badge top_left;
  Badge center;
  Badge bottom_left;
  Badge bottom_right;
};

// Provides an image source for assembling a network icons.
class ASH_PUBLIC_EXPORT NetworkIconImageSource : public gfx::CanvasImageSource {
 public:
  NetworkIconImageSource(const gfx::Size& size,
                         const gfx::ImageSkia& icon,
                         const Badges& badges);

  NetworkIconImageSource(const NetworkIconImageSource&) = delete;
  NetworkIconImageSource& operator=(const NetworkIconImageSource&) = delete;

  ~NetworkIconImageSource() override;

  // gfx::CanvasImageSource:
  void Draw(gfx::Canvas* canvas) override;
  bool HasRepresentationAtAllScales() const override;

 private:
  const gfx::ImageSkia icon_;
  const Badges badges_;
};

// Provides an image source for wireless signal strength icons.
class ASH_PUBLIC_EXPORT SignalStrengthImageSource
    : public gfx::CanvasImageSource {
 public:
  SignalStrengthImageSource(ImageType image_type,
                            SkColor color,
                            const gfx::Size& size,
                            int signal_strength,
                            int padding = 2);

  SignalStrengthImageSource(const SignalStrengthImageSource&) = delete;
  SignalStrengthImageSource& operator=(const SignalStrengthImageSource&) =
      delete;

  ~SignalStrengthImageSource() override;

  // gfx::CanvasImageSource:
  void Draw(gfx::Canvas* canvas) override;
  bool HasRepresentationAtAllScales() const override;

 private:
  void DrawArcs(gfx::Canvas* canvas);
  void DrawBars(gfx::Canvas* canvas);

  ImageType image_type_;
  SkColor color_;

  // On a scale of 0 to kNumNetworkImages - 1, how connected we are.
  int signal_strength_;

  // Padding between outside of icon and edge of the canvas, in dp. This value
  // stays the same regardless of the canvas size.
  const int padding_;
};

// Returns the sized full strength unbadged image for a Wi-Fi network. Used
// for wireless network notifications.
ASH_PUBLIC_EXPORT gfx::ImageSkia GetImageForWifiNetwork(SkColor color,
                                                        gfx::Size size);

}  // namespace network_icon
}  // namespace ash

#endif  // ASH_PUBLIC_CPP_NETWORK_ICON_IMAGE_SOURCE_H_