pair<UniqueHandle, UniqueHandle>
MakePipe()
{
#	if YCL_Win32
	::HANDLE h_raw_read, h_raw_write;

	YCL_CallWin32F(CreatePipe, &h_raw_read, &h_raw_write, {}, 0);

	UniqueHandle h_read(h_raw_read), h_write(h_raw_write);

	YCL_CallWin32F(SetHandleInformation, h_write.get(), HANDLE_FLAG_INHERIT,
		HANDLE_FLAG_INHERIT);
	return {std::move(h_read), std::move(h_write)};
#	elif YCL_API_Has_unistd_h
	int fds[2];

	// TODO: Check whether '::socketpair' is available.
	if(::pipe(fds) != 0)
		ThrowFileOperationFailure("Failed getting file size.");

	auto pr(make_pair(UniqueHandle(fds[0]), UniqueHandle(fds[1])));
	auto check([](UniqueHandle& h, const char* msg){
		// NOTE: %O_NONBLOCK is initially cleared on ::pipe results.
		//	See http://pubs.opengroup.org/onlinepubs/9699919799/.
		if(!(h && h->SetNonblocking()))
			ThrowFileOperationFailure(msg);
	});

	check(pr.first, "Failed making pipe for reading."),
	check(pr.second, "Failed making pipe for writing.");
	return pr;
#	else
#	error "Unsupported platform found."
#	endif
}

DirectoryFindData::DirectoryFindData(const wstring& name)
	: dir_name(name), find_data()
{
	if(ystdex::rtrim(dir_name, L"/\\").empty())
		dir_name = L'.';
	YAssert(dir_name.back() != '\\', "Invalid argument found.");

	using platform::FileOperationFailure;
	const auto attr(::GetFileAttributesW(dir_name.c_str()));
	yconstexpr const auto& msg("Opening directory failed.");

	if(YB_UNLIKELY(attr == INVALID_FILE_ATTRIBUTES))
		// TODO: Call %::GetLastError to distinguish concreate errors.
		throw FileOperationFailure(EINVAL, std::generic_category(), msg);
	if(attr & FILE_ATTRIBUTE_DIRECTORY)
		dir_name += L"\\*";
	else
		throw FileOperationFailure(ENOTDIR, std::generic_category(), msg);
}

 cl_device_id  clutil_platform::get_device_ids(cl_device_type device_type)
 {
     return platform_util->get_device_ids(device_type);
 }

 std::size_t clutil_platform::get_source_size()
 {
     return platform_util->get_source_size();
 }

 void clutil_platform::cl_build_programs()
 {
     platform_util->cl_build_programs();
 }

 void clutil_platform::cl_create_programs_with_source()
 {
     platform_util->cl_create_programs_with_source();
 }

 void clutil_platform::cl_create_context()
 {
     platform_util->cl_create_context();
 }

 void  clutil_platform::context_properties()
 {
     platform_util->context_properties();
 }

 cl_platform_id  clutil_platform::get_platform_ids()
 {
     return platform_util->get_platform_ids();
 }

 std::string clutil_platform::get_platforms_info(cl_platform_info name, std::string str)
 {
     return platform_util->get_platforms_info(name, str);
 }

ItemLoaderRepo::ItemLoaderRepo()
    : Repository<PropertyLoaderBase<Item> >( mDefault )
{
    int32_t id = AutoId( "plasma_gun" );
    mElements.insert( id, new PlasmaGunLoader() );
    id = AutoId( "guard_plasma_gun" );
    mElements.insert( id, new PlasmaGunLoader() );
    id = AutoId( "pistol" );
    mElements.insert( id, new PistolLoader() );
    id = AutoId( "shotgun" );
    mElements.insert( id, new ShotgunLoader() );
    id = AutoId( "rocket_launcher" );
    mElements.insert( id, new RocketLauncherLoader() );
    id = AutoId( "ion_gun" );
    mElements.insert( id, new IonGunLoader() );
    id = AutoId( "gatling_gun" );
    mElements.insert( id, new GatlingGunLoader() );
    id = AutoId( "gauss_gun" );
    mElements.insert( id, new GaussGunLoader() );
    id = AutoId( "lucky_rocket" );
    mElements.insert( id, new LuckyRocketLoader() );
    id = AutoId("rusty_reaper"); 
    mElements.insert(id, new RustyReaperLoader());
    Init();
}

RenderableLayer::RenderableLayer()
{
    mIdToRendLayerMap[AutoId( "background" )] = RenderableLayer::Background;
    mIdToRendLayerMap[AutoId( "background_1" )] = RenderableLayer::Background_1;
    mIdToRendLayerMap[AutoId( "corpses" )] = RenderableLayer::Corpses;
    mIdToRendLayerMap[AutoId( "creeps" )] = RenderableLayer::Creeps;
    mIdToRendLayerMap[AutoId( "players" )] = RenderableLayer::Players;
    mIdToRendLayerMap[AutoId( "buildings" )] = RenderableLayer::Buildings;
}

bool ItemLoaderRepo::LoadItemFromOneDesc( Json::Value& ItemDesc )
{
    std::string nameStr;
    if( !Json::GetStr( ItemDesc["name"], nameStr ) )
    {
        return false;
    }
    PropertyLoaderBase<Item>& itemLoader = operator()( AutoId( nameStr ) );

    Json::Value& setters = ItemDesc["set"];
    if ( !setters.isArray() )
    {
        return false;
    }
    if ( setters.empty() )
    {
        return true;
    }
    L1( "Load item_loader: %s\n", nameStr.c_str() );
    itemLoader.Load( *setters.begin() );
    return true;
}

int fish::getY()
   {
      return plat.getY();
   }

int fish::getExp()
   {
      return plat.getExp();
   }

int fish::askHP(int ID)
   {
       return plat.askHP(ID);
   }

int fish::getID()
   {
       return plat.getID();
   }

int fish::getAtt()
   {
      return plat.getAtt();
   }

bool fish::move(int tx,int ty)
   {
      return plat.move(tx,ty);
   }

int fish::getMaxHP()
   {
      return plat.getMaxHP();
   }