Upload folder using huggingface_hub (part 73)

pool/shard006/C++/0083647_UIPathSelector.cpp

@@ -0,0 +1,74 @@
+/*
+This file is part of AlgAudio.
+
+AlgAudio, Copyright (C) 2015 CeTA - Audiovisual Technology Center
+
+AlgAudio is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+AlgAudio is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with AlgAudio.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "nfd.h"
+#include "UI/UIPathSelector.hpp"
+#include "UI/UIBox.hpp"
+#include "UI/UITextEntry.hpp"
+#include "UI/UIButton.hpp"
+
+namespace AlgAudio{
+  
+UIPathSelector::UIPathSelector(std::weak_ptr<Window> parent_window, std::string p)
+  : UIHBox(parent_window), path(p)
+{
+  
+}
+
+std::shared_ptr<UIPathSelector> UIPathSelector::Create(std::weak_ptr<Window> w, std::string text)
+{
+  std::shared_ptr<UIPathSelector> res(new UIPathSelector(w,text));
+  res->Init();
+  return res;
+}
+
+void UIPathSelector::Init()
+{
+  child_button = UIButton::Create(window,"...");
+  child_entry = UITextEntry::Create(window,path);
+  Insert(child_entry, UIBox::PackMode::WIDE);
+  Insert(child_button, UIBox::PackMode::TIGHT);
+  
+  child_button->SetBorder(false);
+  child_button->SetCustomSize(Size2D(16,16));
+  child_button->SetInnerMargin(0);
+  
+  subscriptions += child_button->on_clicked.Subscribe([this](){
+    OpenDialog();
+  });
+  subscriptions += child_entry->on_edited.Subscribe([this](){
+    path = child_entry->GetText();
+  });
+}
+
+void UIPathSelector::OpenDialog(){
+  nfdchar_t *outPath = nullptr;
+  nfdresult_t result = NFD_OpenDialog( NULL, (path=="") ? NULL : path.c_str() , &outPath );
+  if(result == NFD_OKAY){
+    path = outPath;
+    on_selected.Happen(path);
+    child_entry->SetText(path);
+    free(outPath);
+  }
+}
+
+void UIPathSelector::SetName(std::string t){
+  child_entry->SetDefaultText(t);
+}
+  
+} // namespace AlgAudio

pool/shard006/C++/0083648_current.cpp

@@ -0,0 +1,47 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/alan3/current.h"
+
+namespace Glk {
+namespace Alan3 {
+
+/* PUBLIC DATA */
+CurVars current;
+bool gameStateChanged = FALSE;
+
+void CurVars::synchronize(Common::Serializer &s) {
+	s.syncAsSint32LE(syntax);
+	s.syncAsSint32LE(verb);
+	s.syncAsSint32LE(location);
+	s.syncAsSint32LE(actor);
+	s.syncAsSint32LE(instance);
+	s.syncAsSint32LE(tick);
+	s.syncAsSint32LE(score);
+	s.syncAsSint32LE(visits);
+	s.syncAsSint32LE(sourceLine);
+	s.syncAsSint32LE(sourceFile);
+	s.syncAsUint32LE(meta);
+}
+
+} // End of namespace Alan3
+} // End of namespace Glk

pool/shard006/C++/0083654_82A.cpp

@@ -0,0 +1,34 @@
+#include <cstdio>
+#include <algorithm>
+#include <string.h>
+#include <cmath>
+
+int main() {
+	int n;
+	scanf("%d", &n);
+	int rd = 0;
+	while (pow(2, rd)*5 < n) {
+		n -= pow(2, rd)*5;
+		rd++;
+	}
+	//printf("n = %d, rd = %d\n", n, rd);
+	int take = pow(2, rd);
+	switch (n%take==0?(n/take)-1:n/take) {
+		case 0:
+			printf("Sheldon\n");
+			break;
+		case 1:
+			printf("Leonard\n");
+			break;
+		case 2:
+			printf("Penny\n");
+			break;
+		case 3:
+			printf("Rajesh\n");
+			break;
+		default:
+			printf("Howard\n");
+			break;
+	}
+	return 0;
+}

pool/shard006/C++/0083657_main.cpp

@@ -0,0 +1,211 @@
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include "cat.h"
+
+float average(std::string s);
+void readin(std::ifstream &in, std::vector<Cat> &cats);
+void print(std::ofstream &out, std::vector<Cat> &cats);
+void print_extraLines(std::ofstream &out, std::vector<Cat> &cats);
+void print_extraSpaces(std::ofstream &out, std::vector<Cat> &cats);
+void print_lineOrder(std::ofstream &out, const std::vector<Cat> &cats);
+void print_frontSpacing(std::ofstream &out, std::vector<Cat> &cats);
+void print_columnSpacing(std::ofstream &out, std::vector<Cat> &cats);
+
+//========================================================================================================
+
+int main(int argc, char* argv[])
+{
+	//check command line arguments
+	if(argc != 3)
+	{
+		std::cerr << "Wrong number of command line arguments" << std::endl;
+		exit(1);
+	}
+
+	//open input stream
+	std::ifstream in(argv[1]);
+	if(!in.good())
+	{
+		std::cerr << "Error opening input file" << std::endl;
+		exit(1);
+	}
+
+	//open output stream
+	std::ofstream out(argv[2]);
+	if(!out.good())
+	{
+		std::cerr << "Error opening output file" << std::endl;
+	}
+
+	std::vector<Cat> cats;
+
+	readin(in, cats);
+
+	//call a print function
+	
+	//print(out, cats);
+	//print_extraLines(out, cats);
+	//print_extraSpaces(out, cats);
+	//print_lineOrder(out, cats);
+	//print_frontSpacing(out, cats);
+	print_columnSpacing(out, cats);
+
+	return 0;
+}
+
+//============================================================================================================
+
+//extracts the lower and upper of the range in the string and averages them
+float average(std::string s)
+{
+	//get lower value of the range
+	std::size_t dash = s.find('-');
+	std::size_t start = 0;
+	std::string lowerValue = s.substr(start, dash);
+
+	//get upper value of the range
+	start = dash+1;
+	std::string upperValue = s.substr(start);
+
+	//convert strings to ints
+	int lower;
+	int upper;
+	std::istringstream(lowerValue) >> lower;
+	std::istringstream(upperValue) >> upper;
+
+	return (float)(upper + lower) / 2;
+}
+
+//read in from the input file
+void readin(std::ifstream &in, std::vector<Cat> &cats)
+{
+	std::string breed, lifeSpan, weight;
+	std::string interesting = "";
+	std::string s;
+	std::string classifier;
+	std::string unit;
+	
+	in >> classifier;
+
+	while(!in.eof())
+	{
+		//take in the breed, life span as a string, weight as a string
+		in >> breed;
+		in >> classifier >> lifeSpan >> unit;
+		in >> classifier >> weight >> unit;
+		in >> classifier >> s;
+
+		//take in  the interesting fact about the cat breed
+		while(!in.eof() && s != "BREED:")
+		{
+			interesting += s + " ";
+			in >> s;
+		}
+
+		//get the average from the range of values
+		float weightAverage = average(weight);
+		float lifeSpanAverage = average(lifeSpan);
+
+		cats.push_back(Cat(breed, lifeSpanAverage, weightAverage, interesting));
+
+		interesting = "";
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------------------
+//functions to print
+
+//print the output as expected
+void print(std::ofstream &out, std::vector<Cat> &cats)
+{
+	std::sort(cats.begin(), cats.end(), sortCats);
+	std::string spacing = "     ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() << std::endl;
+		out << spacing << "Average Weight:   " << cats[i].getAverageSize() << std::endl;
+		out << spacing << "Intersting Fact:  " << cats[i].getInterestingFact() << std::endl;
+	}
+}
+
+//print the output with extra newlines at the end of every line
+void print_extraLines(std::ofstream &out, std::vector<Cat> &cats)
+{
+	std::sort(cats.begin(), cats.end(), sortCats);
+	std::string spacing = "     ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << std::endl << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() 
+		    << std::endl << std::endl;
+		out << spacing << "Average Weight:   " << cats[i].getAverageSize() 
+		    << std::endl << std::endl;
+		out << spacing << "Intersting Fact:  " << cats[i].getInterestingFact() 
+		    << std::endl << std::endl;
+	}
+}
+
+//print the output with extra spaces at the end of every line
+void print_extraSpaces(std::ofstream &out, std::vector<Cat> &cats)
+{
+	std::sort(cats.begin(), cats.end(), sortCats);
+	std::string spacing = "     ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << " " << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() 
+		    << " " << std::endl;
+		out << spacing << "Average Weight:   " << cats[i].getAverageSize() 
+		    << " " << std::endl;
+		out << spacing << "Intersting Fact:  " << cats[i].getInterestingFact() 
+		    << " " << std::endl;
+	}
+}
+
+//print the output with the lines in the wrong order
+void print_lineOrder(std::ofstream &out, const std::vector<Cat> &cats)
+{
+	std::string spacing = "     ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() << std::endl;
+		out << spacing << "Average Weight:   " << cats[i].getAverageSize() << std::endl;
+		out << spacing << "Intersting Fact:  " << cats[i].getInterestingFact() << std::endl;
+	}
+}
+
+//print the output with the spacing in front off (expected: 5 spaces)
+void print_frontSpacing(std::ofstream &out, std::vector<Cat> &cats)
+{
+	std::sort(cats.begin(), cats.end(), sortCats);
+	std::string spacing = "   ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() << std::endl;
+		out << spacing << "Average Weight:   " << cats[i].getAverageSize() << std::endl;
+		out << spacing << "Intersting Fact:  " << cats[i].getInterestingFact() << std::endl;
+	}
+}
+
+//print the output with the column spacing off
+//(expected: 1 space between 1st column and 2nd, 1st column the length of the longest attribute)
+void print_columnSpacing(std::ofstream &out, std::vector<Cat> &cats)
+{
+	std::sort(cats.begin(), cats.end(), sortCats);
+	std::string spacing = "     ";
+	for(unsigned int i = 0; i < cats.size(); i++)
+	{
+		out << cats[i].getBreed() << std::endl;
+		out << spacing << "Average Lifespan: " << cats[i].getAverageLifeSpan() << std::endl;
+		out << spacing << "Average Weight: " << cats[i].getAverageSize() << std::endl;
+		out << spacing << "Intersting Fact: " << cats[i].getInterestingFact() << std::endl;
+	}
+}

pool/shard006/C++/0083662_user_script_slave.cc

@@ -0,0 +1,180 @@
+// 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 "chrome/renderer/user_script_slave.h"
+
+#include "app/resource_bundle.h"
+#include "base/histogram.h"
+#include "base/logging.h"
+#include "base/perftimer.h"
+#include "base/pickle.h"
+#include "base/shared_memory.h"
+#include "base/string_util.h"
+#include "googleurl/src/gurl.h"
+#include "webkit/api/public/WebScriptSource.h"
+#include "webkit/glue/webframe.h"
+
+#include "grit/renderer_resources.h"
+
+using WebKit::WebScriptSource;
+using WebKit::WebString;
+
+// These two strings are injected before and after the Greasemonkey API and
+// user script to wrap it in an anonymous scope.
+static const char kUserScriptHead[] = "(function (unsafeWindow) {\n";
+static const char kUserScriptTail[] = "\n})(window);";
+
+// Creates a convenient reference to a content script's parent extension.
+// TODO(mpcomplete): self.onConnect is deprecated.  Remove it at 1.0.
+// http://code.google.com/p/chromium/issues/detail?id=16356
+static const char kInitExtension[] =
+    "chrome.extension = new chrome.Extension('%s');"
+    "chrome.self.onConnect = chrome.extension.onConnect;";
+
+UserScriptSlave::UserScriptSlave()
+    : shared_memory_(NULL),
+      script_deleter_(&scripts_),
+      user_script_start_line_(0) {
+  // TODO: Only windows supports resources and only windows supports user
+  // scrips, so only load the Greasemonkey API on windows.  Fix this when
+  // better cross platofrm support is available.
+#if defined(OS_WIN)
+  api_js_ = ResourceBundle::GetSharedInstance().GetRawDataResource(
+                IDR_GREASEMONKEY_API_JS);
+#endif
+
+  // Count the number of lines that will be injected before the user script.
+  StringPiece::size_type pos = 0;
+  while ((pos = api_js_.find('\n', pos)) != StringPiece::npos) {
+    user_script_start_line_++;
+    pos++;
+  }
+
+  // NOTE: There is actually one extra line in the injected script because the
+  // function header includes a newline as well. But WebKit expects the
+  // numbering to be one-based, not zero-based, so actually *not* accounting for
+  // this extra line ends us up with the right offset.
+}
+
+bool UserScriptSlave::UpdateScripts(base::SharedMemoryHandle shared_memory) {
+  scripts_.clear();
+
+  // Create the shared memory object (read only).
+  shared_memory_.reset(new base::SharedMemory(shared_memory, true));
+  if (!shared_memory_.get())
+    return false;
+
+  // First get the size of the memory block.
+  if (!shared_memory_->Map(sizeof(Pickle::Header)))
+    return false;
+  Pickle::Header* pickle_header =
+      reinterpret_cast<Pickle::Header*>(shared_memory_->memory());
+
+  // Now map in the rest of the block.
+  int pickle_size = sizeof(Pickle::Header) + pickle_header->payload_size;
+  shared_memory_->Unmap();
+  if (!shared_memory_->Map(pickle_size))
+    return false;
+
+  // Unpickle scripts.
+  void* iter = NULL;
+  size_t num_scripts = 0;
+  Pickle pickle(reinterpret_cast<char*>(shared_memory_->memory()),
+                pickle_size);
+  pickle.ReadSize(&iter, &num_scripts);
+
+  scripts_.reserve(num_scripts);
+  for (size_t i = 0; i < num_scripts; ++i) {
+    scripts_.push_back(new UserScript());
+    UserScript* script = scripts_.back();
+    script->Unpickle(pickle, &iter);
+
+    // Note that this is a pointer into shared memory. We don't own it. It gets
+    // cleared up when the last renderer or browser process drops their
+    // reference to the shared memory.
+    for (size_t j = 0; j < script->js_scripts().size(); ++j) {
+      const char* body = NULL;
+      int body_length = 0;
+      CHECK(pickle.ReadData(&iter, &body, &body_length));
+      script->js_scripts()[j].set_external_content(
+          StringPiece(body, body_length));
+    }
+    for (size_t j = 0; j < script->css_scripts().size(); ++j) {
+      const char* body = NULL;
+      int body_length = 0;
+      CHECK(pickle.ReadData(&iter, &body, &body_length));
+      script->css_scripts()[j].set_external_content(
+          StringPiece(body, body_length));
+    }
+  }
+
+  return true;
+}
+
+bool UserScriptSlave::InjectScripts(WebFrame* frame,
+                                    UserScript::RunLocation location) {
+  PerfTimer timer;
+  int num_matched = 0;
+
+  for (size_t i = 0; i < scripts_.size(); ++i) {
+    std::vector<WebScriptSource> sources;
+    UserScript* script = scripts_[i];
+    if (!script->MatchesUrl(frame->GetURL()))
+      continue;  // This frame doesn't match the script url pattern, skip it.
+
+    ++num_matched;
+    // CSS files are always injected on document start before js scripts.
+    if (location == UserScript::DOCUMENT_START) {
+      for (size_t j = 0; j < script->css_scripts().size(); ++j) {
+        UserScript::File& file = script->css_scripts()[j];
+        frame->InsertCSSStyles(file.GetContent().as_string());
+      }
+    }
+    if (script->run_location() == location) {
+      for (size_t j = 0; j < script->js_scripts().size(); ++j) {
+        UserScript::File &file = script->js_scripts()[j];
+        std::string content = file.GetContent().as_string();
+
+        // We add this dumb function wrapper for standalone user script to
+        // emulate what Greasemonkey does.
+        if (script->is_standalone()) {
+          content.insert(0, kUserScriptHead);
+          content += kUserScriptTail;
+        }
+        sources.push_back(WebScriptSource(
+            WebString::fromUTF8(content.c_str(), content.length()),
+            file.url()));
+      }
+    }
+
+    if (!sources.empty()) {
+      if (script->is_standalone()) {
+        // For standalone scripts, we try to emulate the Greasemonkey API.
+        sources.insert(sources.begin(),
+            WebScriptSource(WebString::fromUTF8(api_js_.as_string())));
+      } else {
+        // Setup chrome.self to contain an Extension object with the correct
+        // ID.
+        sources.insert(sources.begin(),
+            WebScriptSource(WebString::fromUTF8(
+                StringPrintf(kInitExtension, script->extension_id().c_str()))));
+      }
+
+      frame->ExecuteScriptInNewContext(&sources.front(), sources.size());
+    }
+  }
+
+  // Log debug info.
+  if (location == UserScript::DOCUMENT_START) {
+    HISTOGRAM_COUNTS_100("UserScripts:DocStart:Count", num_matched);
+    HISTOGRAM_TIMES("UserScripts:DocStart:Time", timer.Elapsed());
+  } else {
+    HISTOGRAM_COUNTS_100("UserScripts:DocEnd:Count", num_matched);
+    HISTOGRAM_TIMES("UserScripts:DocEnd:Time", timer.Elapsed());
+  }
+
+  LOG(INFO) << "Injected " << num_matched << " user scripts into " <<
+      frame->GetURL().spec();
+  return true;
+}

pool/shard006/C++/0083663_MPHasher.cpp

@@ -0,0 +1,78 @@
+#include "MPHasher.h"
+#include "EventTypeName.h"
+#include <algorithm>
+
+namespace mParticle {
+    __attribute__((no_sanitize("integer")))
+    int Hasher::hashFromString(const string &stringToHash) {
+        if (stringToHash.empty()) {
+            return 0;
+        }
+
+        string lowerCaseStringToHash = stringToHash;
+        transform(lowerCaseStringToHash.begin(), lowerCaseStringToHash.end(), lowerCaseStringToHash.begin(), ::tolower);
+        
+        int hash = 0;
+        for (auto &character : lowerCaseStringToHash) {
+            hash = ((hash << 5) - hash) + character;
+        }
+        
+        return hash;
+    }
+
+    string Hasher::hashString(string stringToHash) {
+        if (stringToHash.empty()) {
+            return "";
+        }
+        
+        auto hash = Hasher::hashFromString(stringToHash);
+        
+        auto hashString = to_string(hash);
+        return hashString;
+    }
+    
+    vector<string> Hasher::hashedEventTypes(const vector<int> &eventTypes) {
+        vector<string> hashedTypes;
+
+        if (eventTypes.empty()) {
+            return hashedTypes;
+        }
+        
+        for (auto &eventType : eventTypes) {
+            auto eventTypeString = to_string(eventType);
+            auto hashedEventType = Hasher::hashString(eventTypeString);
+            hashedTypes.push_back(hashedEventType);
+        }
+        
+        return hashedTypes;
+    }
+    
+    vector<string> Hasher::hashedAllEventTypes() {
+        vector<int> eventTypes(EventTypeName::count);
+        
+        int i = 0;
+        for_each(eventTypes.begin(), eventTypes.end(), [&i](int &eventType) {eventType = i++;});
+        
+        vector<string> hashes = Hasher::hashedEventTypes(eventTypes);
+        return hashes;
+    }
+    
+    string Hasher::hashEvent(string eventName, string eventType) {
+        eventName.append(eventType);
+        return Hasher::hashString(eventName);
+    }
+
+    __attribute__((no_sanitize("integer")))
+    int64_t Hasher::hashFNV1a(const char *bytes, int length) {
+        // FNV-1a hashing
+        int64_t rampHash = 0xcbf29ce484222325;
+        
+        int i = 0;
+        while (i < length) {
+            rampHash = (rampHash ^ bytes[i]) * 0x100000001B3;
+            i += 1;
+        }
+        
+        return rampHash;
+    }
+}

pool/shard006/C++/0083666_clientsideeffects_test.cpp

@@ -0,0 +1,302 @@
+//======== (C) Copyright 1999, 2000 Valve, L.L.C. All rights reserved. ========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================
+#include "cbase.h"
+#include "engine/IEngineSound.h"
+#include "view.h"
+
+#include "fx_line.h"
+#include "fx_discreetline.h"
+#include "fx_quad.h"
+#include "clientsideeffects.h"
+
+#include "SoundEmitterSystemBase.h"
+#include "tier0/vprof.h"
+
+//FIXME: All these functions will be moved out to FX_Main.CPP or a individual folder
+
+/*
+==================================================
+FX_AddStaticLine
+==================================================
+*/
+
+void FX_AddStaticLine( const Vector& start, const Vector& end, float scale, float life, const char *materialName, unsigned char flags )
+{
+	CFXStaticLine	*t = new CFXStaticLine( "StaticLine", start, end, scale, life, materialName, flags );
+	assert( t );
+
+	//Throw it into the list
+	clienteffects->AddEffect( t );
+}
+
+/*
+==================================================
+FX_AddDiscreetLine
+==================================================
+*/
+
+void FX_AddDiscreetLine( const Vector& start, const Vector& direction, float velocity, float length, float clipLength, float scale, float life, const char *shader )
+{
+	CFXDiscreetLine	*t = new CFXDiscreetLine( "Line", start, direction, velocity, length, clipLength, scale, life, shader );
+	assert( t );
+
+	//Throw it into the list
+	clienteffects->AddEffect( t );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void FX_AddQuad( const FXQuadData_t &data )
+{
+	CFXQuad *quad = new CFXQuad( data );
+
+	Assert( quad != NULL );
+
+	clienteffects->AddEffect( quad );
+}
+//-----------------------------------------------------------------------------
+// Purpose: Parameter heavy version
+//-----------------------------------------------------------------------------
+void FX_AddQuad( const Vector &origin, 
+				 const Vector &normal, 
+				 float startSize, 
+				 float endSize, 
+				 float sizeBias,
+				 float startAlpha, 
+				 float endAlpha,
+				 float alphaBias,
+				 float yaw,
+				 float deltaYaw,
+				 const Vector &color, 
+				 float lifeTime, 
+				 const char *shader, 
+				 unsigned int flags )
+{
+	FXQuadData_t data;
+
+	//Setup the data
+	data.SetAlpha( startAlpha, endAlpha );
+	data.SetScale( startSize, endSize );
+	data.SetFlags( flags );
+	data.SetMaterial( shader );
+	data.SetNormal( normal );
+	data.SetOrigin( origin );
+	data.SetLifeTime( lifeTime );
+	data.SetColor( color[0], color[1], color[2] );
+	data.SetScaleBias( sizeBias );
+	data.SetAlphaBias( alphaBias );
+	data.SetYaw( yaw, deltaYaw );
+
+	//Output it
+	FX_AddQuad( data );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a test effect
+//-----------------------------------------------------------------------------
+void CreateTestEffect( void )
+{
+	//NOTENOTE: Add any test effects here
+	//FX_BulletPass( NULL, NULL );
+}
+
+/*
+==================================================
+UTIL_NearestPointOnLine
+==================================================
+*/
+
+float UTIL_NearestPointOnLine( const Vector& start, const Vector& end, const Vector& target, Vector& out )
+{
+	Vector	lineDir, targetDir;
+	float	dot;
+
+	//Find the direction of the line
+	VectorSubtract( end, start, lineDir );
+	VectorNormalize( lineDir );
+
+	//Find the direction of the target to the line's path
+	VectorSubtract( target, start, targetDir );
+		
+	//Find the nearest point to the target on that line
+	dot = DotProduct( targetDir, lineDir );
+	VectorScale( lineDir, dot, out );
+	VectorAdd( start, out, out );
+
+	//Find the distance to the nearest point
+	VectorSubtract( out, target, targetDir );
+	
+	return VectorLength( targetDir );
+}
+
+/*
+==================================================
+FX_PlayerTracer
+==================================================
+*/
+
+#define	TRACER_BASE_OFFSET	8
+
+void FX_PlayerTracer( Vector& start, Vector& end )
+{
+	VPROF_BUDGET( "FX_PlayerTracer", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
+	Vector	shotDir, dStart, dEnd;
+	float	length;
+
+	//Find the direction of the tracer
+	VectorSubtract( end, start, shotDir );
+	length = VectorNormalize( shotDir );
+
+	//We don't want to draw them if they're too close to us
+	if ( length < 256 )
+		return;
+
+	//Randomly place the tracer along this line, with a random length
+	VectorMA( start, TRACER_BASE_OFFSET + random->RandomFloat( -24.0f, 64.0f ), shotDir, dStart );
+	VectorMA( dStart, ( length * random->RandomFloat( 0.1f, 0.6f ) ), shotDir, dEnd );
+
+	//Create the line
+	CFXStaticLine	*t;
+	const char		*materialName;
+
+	//materialName = ( random->RandomInt( 0, 1 ) ) ? "effects/tracer_middle" : "effects/tracer_middle2";
+	materialName = "effects/spark";
+
+	t = new CFXStaticLine( "Tracer", dStart, dEnd, random->RandomFloat( 0.5f, 0.75f ), 0.01f, materialName, 0 );
+	assert( t );
+
+	//Throw it into the list
+	clienteffects->AddEffect( t );
+}
+
+/*
+==================================================
+FX_Tracer
+==================================================
+*/
+// Tracer must be this close to be considered for hearing
+#define	TRACER_MAX_HEAR_DIST	(6*12)
+#define TRACER_SOUND_TIME_MIN	0.10f
+#define TRACER_SOUND_TIME_MAX	0.10f
+
+
+class CBulletWhizTimer : public CAutoGameSystem
+{
+public:
+	void LevelInitPreEntity()
+	{
+		m_nextWhizTime = 0;
+	}
+
+	float	m_nextWhizTime;
+};
+
+// Client-side tracking for whiz noises
+CBulletWhizTimer g_BulletWhiz;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &vecStart - 
+//			&vecDir - 
+//			iTracerType - 
+//-----------------------------------------------------------------------------
+void FX_TracerSound( const Vector &start, const Vector &end, int iTracerType )
+{
+	const char *pszSoundName = NULL;
+
+	switch( iTracerType )
+	{
+	case TRACER_TYPE_DEFAULT:
+		pszSoundName = "Bullets.DefaultNearmiss";
+		break;
+
+	case TRACER_TYPE_GUNSHIP:
+		pszSoundName = "Bullets.GunshipNearmiss";
+		break;
+
+	case TRACER_TYPE_STRIDER:
+		pszSoundName = "Bullets.StriderNearmiss";
+		break;
+
+	default:
+		return;
+		break;
+	}
+
+	if( pszSoundName )
+	{
+		//Get out shot direction and length
+		float totalDist;
+		Vector shotDir;
+
+		VectorSubtract( end, start, shotDir );
+		totalDist = VectorNormalize( shotDir );
+
+		float dt = g_BulletWhiz.m_nextWhizTime - gpGlobals->curtime;
+
+		//If needed, make a bullet whiz noise
+		if ( dt <= 0 )
+		{
+			Vector	vNear, dStart, dEnd;
+
+			//Find the nearest point to our view on the bullet's path
+			float vDist = UTIL_NearestPointOnLine( start, end, MainViewOrigin(), vNear );
+
+			//See if we should play a bullet whizz				
+			if ( vDist <= TRACER_MAX_HEAR_DIST )
+			{
+				CLocalPlayerFilter filter;
+				CSoundParameters params;
+
+				if( C_BaseEntity::GetParametersForSound( pszSoundName, params ) )
+				{
+					enginesound->EmitSound(	filter, SOUND_FROM_WORLD, CHAN_STATIC, params.soundname, params.volume, SNDLVL_TO_ATTN(params.soundlevel), 0, params.pitch, &start, &shotDir, false);
+				}
+
+				//Don't play another bullet whiz for this client until this time has run out
+				g_BulletWhiz.m_nextWhizTime = gpGlobals->curtime + random->RandomFloat( TRACER_SOUND_TIME_MIN, TRACER_SOUND_TIME_MAX );
+
+			}
+		}
+	}
+}
+
+
+void FX_Tracer( Vector& start, Vector& end, int velocity, bool makeWhiz )
+{
+	VPROF_BUDGET( "FX_Tracer", VPROF_BUDGETGROUP_PARTICLE_RENDERING );
+	//Don't make small tracers
+	float dist;
+	Vector dir;
+
+	VectorSubtract( end, start, dir );
+	dist = VectorNormalize( dir );
+
+	// Don't make short tracers.
+	if ( dist < 256 )
+	{
+		return;
+	}
+
+	float length = random->RandomFloat( 64.0f, 128.0f );
+	float life = ( dist + length ) / velocity;	//NOTENOTE: We want the tail to finish its run as well
+	
+	//Add it
+	FX_AddDiscreetLine( start, dir, velocity, length, dist, random->RandomFloat( 0.75f, 0.9f ), life, "effects/spark" );
+
+	if( makeWhiz )
+	{
+		FX_TracerSound( start, end, TRACER_TYPE_DEFAULT );	
+	}
+}

pool/shard006/C++/0083671_test_context_provider_factory.cc

@@ -0,0 +1,46 @@
+// Copyright (c) 2013 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 "webkit/gpu/test_context_provider_factory.h"
+
+#include "base/logging.h"
+#include "cc/output/context_provider.h"
+#include "webkit/gpu/context_provider_in_process.h"
+
+namespace webkit {
+namespace gpu {
+
+static TestContextProviderFactory* context_provider_instance = NULL;
+
+// static
+TestContextProviderFactory* TestContextProviderFactory::GetInstance() {
+  if (!context_provider_instance)
+    context_provider_instance = new TestContextProviderFactory();
+  return context_provider_instance;
+}
+
+TestContextProviderFactory::TestContextProviderFactory() {}
+
+TestContextProviderFactory::~TestContextProviderFactory() {}
+
+scoped_refptr<cc::ContextProvider> TestContextProviderFactory::
+    OffscreenContextProviderForMainThread() {
+  if (!main_thread_ || main_thread_->DestroyedOnMainThread()) {
+    main_thread_ = ContextProviderInProcess::Create();
+    if (main_thread_ && !main_thread_->BindToCurrentThread())
+      main_thread_ = NULL;
+  }
+  return main_thread_;
+}
+
+scoped_refptr<cc::ContextProvider> TestContextProviderFactory::
+    OffscreenContextProviderForCompositorThread() {
+  if (!compositor_thread_ ||
+      compositor_thread_->DestroyedOnMainThread())
+    compositor_thread_ = ContextProviderInProcess::Create();
+  return compositor_thread_;
+}
+
+}  // namespace gpu
+}  // namespace webkit

pool/shard006/C++/0083679_rtcp_format_remb_unittest.cc

@@ -0,0 +1,136 @@
+/*
+ *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+#include "webrtc/common_types.h"
+#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
+#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/typedefs.h"
+
+namespace {
+
+using namespace webrtc;
+
+
+class TestTransport : public Transport {
+ public:
+  TestTransport(RTCPReceiver* rtcp_receiver) :
+    rtcp_receiver_(rtcp_receiver) {
+  }
+
+  virtual int SendPacket(int /*channel*/, const void* /*data*/, int /*len*/) {
+    return -1;
+  }
+  virtual int SendRTCPPacket(int /*channel*/,
+                             const void *packet,
+                             int packetLength) {
+    RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet,
+                                         (int32_t)packetLength,
+                                         true); // Allow non-compound RTCP
+
+    EXPECT_TRUE(rtcpParser.IsValid());
+    RTCPHelp::RTCPPacketInformation rtcpPacketInformation;
+    EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation,
+                                                    &rtcpParser));
+
+    EXPECT_EQ((uint32_t)kRtcpRemb,
+              rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRemb);
+    EXPECT_EQ((uint32_t)1234,
+              rtcpPacketInformation.receiverEstimatedMaxBitrate);
+    return packetLength;
+  }
+ private:
+  RTCPReceiver* rtcp_receiver_;
+};
+
+
+class RtcpFormatRembTest : public ::testing::Test {
+ protected:
+  static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
+
+  RtcpFormatRembTest()
+      : over_use_detector_options_(),
+        system_clock_(Clock::GetRealTimeClock()),
+        receive_statistics_(ReceiveStatistics::Create(system_clock_)),
+        remote_bitrate_observer_(),
+        remote_bitrate_estimator_(
+            RemoteBitrateEstimatorFactory().Create(
+                &remote_bitrate_observer_,
+                system_clock_,
+                kMimdControl,
+                kRemoteBitrateEstimatorMinBitrateBps)) {}
+  virtual void SetUp();
+  virtual void TearDown();
+
+  OverUseDetectorOptions over_use_detector_options_;
+  Clock* system_clock_;
+  ModuleRtpRtcpImpl* dummy_rtp_rtcp_impl_;
+  scoped_ptr<ReceiveStatistics> receive_statistics_;
+  RTCPSender* rtcp_sender_;
+  RTCPReceiver* rtcp_receiver_;
+  TestTransport* test_transport_;
+  MockRemoteBitrateObserver remote_bitrate_observer_;
+  scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
+};
+
+void RtcpFormatRembTest::SetUp() {
+  RtpRtcp::Configuration configuration;
+  configuration.id = 0;
+  configuration.audio = false;
+  configuration.clock = system_clock_;
+  configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
+  dummy_rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
+  rtcp_sender_ =
+      new RTCPSender(0, false, system_clock_, receive_statistics_.get());
+  rtcp_receiver_ = new RTCPReceiver(0, system_clock_, dummy_rtp_rtcp_impl_);
+  test_transport_ = new TestTransport(rtcp_receiver_);
+
+  EXPECT_EQ(0, rtcp_sender_->Init());
+  EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_));
+}
+
+void RtcpFormatRembTest::TearDown() {
+  delete rtcp_sender_;
+  delete rtcp_receiver_;
+  delete dummy_rtp_rtcp_impl_;
+  delete test_transport_;
+}
+
+TEST_F(RtcpFormatRembTest, TestBasicAPI) {
+  EXPECT_FALSE(rtcp_sender_->REMB());
+  EXPECT_EQ(0, rtcp_sender_->SetREMBStatus(true));
+  EXPECT_TRUE(rtcp_sender_->REMB());
+  EXPECT_EQ(0, rtcp_sender_->SetREMBStatus(false));
+  EXPECT_FALSE(rtcp_sender_->REMB());
+
+  EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 0, NULL));
+}
+
+TEST_F(RtcpFormatRembTest, TestNonCompund) {
+  uint32_t SSRC = 456789;
+  EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpNonCompound));
+  EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 1, &SSRC));
+  RTCPSender::FeedbackState feedback_state(dummy_rtp_rtcp_impl_);
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRemb));
+}
+
+TEST_F(RtcpFormatRembTest, TestCompund) {
+  uint32_t SSRCs[2] = {456789, 98765};
+  EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
+  EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 2, SSRCs));
+  RTCPSender::FeedbackState feedback_state(dummy_rtp_rtcp_impl_);
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRemb));
+}
+}  // namespace

pool/shard006/C++/0083681_viewbasis_funcs.cpp

@@ -0,0 +1,112 @@
+/*
+	*** Qt GUI: View Basis dialog functions
+	*** src/gui/viewbasis_funcs.cpp
+	Copyright T. Youngs 2007-2015
+
+	This file is part of Aten.
+
+	Aten is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	Aten is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Aten.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "main/aten.h"
+#include "gui/viewbasis.h"
+#include "gui/mainwindow.h"
+#include "base/messenger.h"
+#include "base/sysfunc.h"
+#include "model/model.h"
+
+// Constructor
+AtenViewBasis::AtenViewBasis(QWidget* parent, Qt::WindowFlags flags) : QDialog(parent,flags)
+{
+	// Private variables
+	target_ = NULL;
+
+	ui.setupUi(this);
+}
+
+void AtenViewBasis::showWindow(Model* m)
+{
+	// Clear old contents
+	ui.BasisTable->clear();
+	ui.BasisTable->setColumnCount(10);
+	ui.BasisTable->setHorizontalHeaderLabels(QStringList() << "Atom" << "Shell" << "Type" << "Exponent" << "Coefficients" << " " << " " << " " << " " << " " );
+	// Check model pointer
+	if (m == NULL) return;
+	// If no basis definition exists in the supplied model, try to look at the trajectory parent
+	target_ = m;
+	if ((target_->basisShells() == NULL) && (target_->parent() != NULL))
+	{
+		target_ = target_->parent();
+		Messenger::print("No basis definition found in trajectory frame - looking in parent model...");
+	}
+	// Determine total row count
+	BasisShell *bas;
+	BasisPrimitive* prim;
+	int row = 0, shell, lastid = -1, n, ncartesians = 0;
+	Dnchar text;
+	for (bas = target_->basisShells(); bas != NULL; bas = bas->next) row += bas->nPrimitives();
+	ui.BasisTable->setRowCount(row);
+	ui.BasisShellsLabel->setText(itoa(target_->nBasisShells()));
+	// Populate table
+	QTableWidgetItem *tabitem;
+	row = 0;
+	shell = 0;
+	for (bas = target_->basisShells(); bas != NULL; bas = bas->next)
+	{
+		++shell;
+		ncartesians += BasisShell::nCartesianFunctions(bas->type());
+		// Create atom id item?
+		if (lastid != bas->atomId())
+		{
+			lastid = bas->atomId();
+			tabitem = new QTableWidgetItem();
+			text.sprintf("%i (%s)\n", lastid+1, m->atom(lastid) != NULL ? Elements().symbol(m->atom(lastid)) : "NULL");
+			tabitem->setText(text.get());
+			ui.BasisTable->setItem(row, AtenViewBasis::AtomIdColumn, tabitem);
+		}
+		// Add in shell data
+		tabitem = new QTableWidgetItem();
+		tabitem->setText(itoa(shell));
+		ui.BasisTable->setItem(row, AtenViewBasis::ShellColumn, tabitem);
+		tabitem = new QTableWidgetItem();
+		tabitem->setText(BasisShell::basisShellType(bas->type()));
+		ui.BasisTable->setItem(row, AtenViewBasis::TypeColumn, tabitem);
+
+		// Cycle over primitives
+		n = 0;
+		for (prim = bas->primitives(); prim != NULL; prim = prim->next)
+		{
+			tabitem = new QTableWidgetItem();
+			tabitem->setText(ftoa(prim->exponent()));
+			ui.BasisTable->setItem(row, AtenViewBasis::ExponentColumn, tabitem);
+			for (n = 0; n < prim->nCoefficients(); ++n)
+			{
+				tabitem = new QTableWidgetItem();
+				tabitem->setText(ftoa(prim->coefficient(n)));
+				ui.BasisTable->setItem(row, AtenViewBasis::CoefficientColumn+n, tabitem);
+			}
+			row++;
+		}
+	}
+	ui.BasisCartesiansLabel->setText(itoa(ncartesians));
+	// Resize columns
+	for (n=0; n<AtenViewBasis::nColumns; ++n) ui.BasisTable->resizeColumnToContents(n);
+	show();
+}
+
+void AtenViewBasis::dialogFinished(int result)
+{
+	accept();
+}
+

pool/shard006/C++/0083683_osc_route_observer.cc

@@ -0,0 +1,107 @@
+/*
+    Copyright (C) 2009 Paul Davis
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include "boost/lambda/lambda.hpp"
+
+#include "ardour/route.h"
+#include "ardour/audio_track.h"
+#include "ardour/midi_track.h"
+
+#include "osc.h"
+#include "osc_route_observer.h"
+
+#include "i18n.h"
+
+using namespace std;
+using namespace sigc;
+using namespace PBD;
+using namespace ARDOUR;
+using namespace boost;
+
+OSCRouteObserver::OSCRouteObserver (boost::shared_ptr<Route> r, lo_address a)
+	: _route (r)
+{
+	addr = lo_address_new (lo_address_get_hostname(a) , lo_address_get_port(a));
+	
+	_route->PropertyChanged.connect (name_changed_connection, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::name_changed, this, boost::lambda::_1), OSC::instance());
+
+	if (dynamic_pointer_cast<AudioTrack>(_route) || dynamic_pointer_cast<MidiTrack>(_route)) {
+
+		boost::shared_ptr<Track> track = dynamic_pointer_cast<Track>(r);
+		boost::shared_ptr<Controllable> rec_controllable = dynamic_pointer_cast<Controllable>(track->rec_enable_control());
+
+		rec_controllable->Changed.connect (rec_changed_connection, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/route/rec"), track->rec_enable_control()), OSC::instance());
+	}
+	
+	boost::shared_ptr<Controllable> mute_controllable = dynamic_pointer_cast<Controllable>(_route->mute_control());
+	mute_controllable->Changed.connect (mute_changed_connection, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/route/mute"), _route->mute_control()), OSC::instance());
+
+	boost::shared_ptr<Controllable> solo_controllable = dynamic_pointer_cast<Controllable>(_route->solo_control());
+	solo_controllable->Changed.connect (solo_changed_connection, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/route/solo"), _route->solo_control()), OSC::instance());
+
+	boost::shared_ptr<Controllable> gain_controllable = dynamic_pointer_cast<Controllable>(_route->gain_control());
+	gain_controllable->Changed.connect (gain_changed_connection, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/route/gain"), _route->gain_control()), OSC::instance());
+}
+
+OSCRouteObserver::~OSCRouteObserver ()
+{
+	name_changed_connection.disconnect();
+	rec_changed_connection.disconnect();
+	mute_changed_connection.disconnect();
+	solo_changed_connection.disconnect();
+	gain_changed_connection.disconnect();
+
+	lo_address_free (addr);
+}
+
+void
+OSCRouteObserver::name_changed (const PBD::PropertyChange& what_changed)
+{
+	if (!what_changed.contains (ARDOUR::Properties::name)) {
+	    return;
+	}
+	
+	if (!_route) {
+		return;
+	}
+	
+	lo_message msg = lo_message_new ();
+
+	lo_message_add_int32 (msg, _route->remote_control_id());
+	lo_message_add_string (msg, _route->name().c_str());
+
+	lo_send_message (addr, "/route/name", msg);
+	lo_message_free (msg);
+}
+
+void
+OSCRouteObserver::send_change_message (string path, boost::shared_ptr<Controllable> controllable)
+{
+	lo_message msg = lo_message_new ();
+
+	lo_message_add_int32 (msg, _route->remote_control_id());
+	lo_message_add_float (msg, (float) controllable->get_value());
+
+	/* XXX thread issues */
+
+	//std::cerr << "ORC: send " << path << " = " << controllable->get_value() << std::endl;
+
+	lo_send_message (addr, path.c_str(), msg);
+	lo_message_free (msg);
+}

pool/shard006/C++/0083689_mode_fbwa.cpp

@@ -0,0 +1,37 @@
+#include "mode.h"
+#include "Plane.h"
+
+void ModeFBWA::update()
+{
+    // set nav_roll and nav_pitch using sticks
+    plane.nav_roll_cd  = plane.channel_roll->norm_input() * plane.roll_limit_cd;
+    plane.update_load_factor();
+    float pitch_input = plane.channel_pitch->norm_input();
+    if (pitch_input > 0) {
+        plane.nav_pitch_cd = pitch_input * plane.aparm.pitch_limit_max_cd;
+    } else {
+        plane.nav_pitch_cd = -(pitch_input * plane.pitch_limit_min_cd);
+    }
+    plane.adjust_nav_pitch_throttle();
+    plane.nav_pitch_cd = constrain_int32(plane.nav_pitch_cd, plane.pitch_limit_min_cd, plane.aparm.pitch_limit_max_cd.get());
+    if (plane.fly_inverted()) {
+        plane.nav_pitch_cd = -plane.nav_pitch_cd;
+    }
+    if (plane.failsafe.rc_failsafe && plane.g.fs_action_short == FS_ACTION_SHORT_FBWA) {
+        // FBWA failsafe glide
+        plane.nav_roll_cd = 0;
+        plane.nav_pitch_cd = 0;
+        SRV_Channels::set_output_limit(SRV_Channel::k_throttle, SRV_Channel::Limit::MIN);
+    }
+    RC_Channel *chan = rc().find_channel_for_option(RC_Channel::AUX_FUNC::FBWA_TAILDRAGGER);
+    if (chan != nullptr) {
+        // check for the user enabling FBWA taildrag takeoff mode
+        bool tdrag_mode = chan->get_aux_switch_pos() == RC_Channel::AuxSwitchPos::HIGH;
+        if (tdrag_mode && !plane.auto_state.fbwa_tdrag_takeoff_mode) {
+            if (plane.auto_state.highest_airspeed < plane.g.takeoff_tdrag_speed1) {
+                plane.auto_state.fbwa_tdrag_takeoff_mode = true;
+                plane.gcs().send_text(MAV_SEVERITY_WARNING, "FBWA tdrag mode");
+            }
+        }
+    }
+}

pool/shard006/C++/0083690_DigitalGlitchFilterJNI.cpp

@@ -0,0 +1,68 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2016. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+#include <jni.h>
+#include "HAL/HAL.hpp"
+#include "HALUtil.h"
+
+#include "edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI.h"
+
+/*
+ * Class:     edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI
+ * Method:    setFilterSelect
+ */
+JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI_setFilterSelect
+  (JNIEnv* env, jclass, jlong port_pointer, jint filter_index)
+{
+  int32_t status = 0;
+  void* digital_port_pointer = reinterpret_cast<void*>(port_pointer);
+
+  setFilterSelect(digital_port_pointer, filter_index, &status);
+  CheckStatus(env, status);
+}
+
+/*
+ * Class:     edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI
+ * Method:    getFilterSelect
+ */
+JNIEXPORT jint JNICALL Java_edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI_getFilterSelect
+  (JNIEnv *env, jclass, jlong port_pointer)
+{
+  int32_t status = 0;
+  void* digital_port_pointer = reinterpret_cast<void*>(port_pointer);
+
+  jint result = getFilterSelect(digital_port_pointer, &status);
+  CheckStatus(env, status);
+  return result;
+}
+
+/*
+ * Class:     edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI
+ * Method:    setFilterPeriod
+ */
+JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI_setFilterPeriod
+  (JNIEnv *env, jclass, jint filter_index, jint fpga_cycles)
+{
+  int32_t status = 0;
+
+  setFilterPeriod(filter_index, fpga_cycles, &status);
+  CheckStatus(env, status);
+}
+
+/*
+ * Class:     edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI
+ * Method:    getFilterPeriod
+ */
+JNIEXPORT jint JNICALL Java_edu_wpi_first_wpilibj_hal_DigitalGlitchFilterJNI_getFilterPeriod
+  (JNIEnv *env, jclass, jint filter_index)
+{
+  int32_t status = 0;
+
+  jint result = getFilterPeriod(filter_index, &status);
+  CheckStatus(env, status);
+  return result;
+}

pool/shard006/C++/0083691_uncle.cpp

@@ -0,0 +1,417 @@
+/**
+ * @file uncle.cpp
+ * @brief Purpose: Contains uncle's methods.
+ *
+ * MIT License
+ * Copyright (c) 2017 MindScape
+ *
+ * https://github.com/TecProg2017-2/mindscape/blob/master/LICENSE.md
+ */
+
+#include "uncle.hpp"
+#include "platform.hpp"
+#include "little_girl.hpp"
+#include "log.hpp"
+#include <stdlib.h>
+
+using namespace mindscape;
+
+/**
+ * @brief Initializes Uncle enemy.
+ *
+ * Constructor responsible to initialize Uncle in game.
+ *
+ * @param name Object's name.
+ * @param position X and Y axis positions.
+ * @param priority Rendering priority object.
+ */
+
+Uncle::Uncle(
+  		std::string name,
+  		std::pair<int, int> position,
+  		int priority
+	):Enemy(
+    	name,
+    	position,
+    	priority,
+    	100
+  	){
+        /* Initialize all the characterists of the Uncle's boss. */
+    	initialize_state_map();
+    	initialize_hitboxes();
+    	initialize_animations();
+    	initialize_audio_effects();
+};
+
+/**
+ * @brief Creates Uncle's animation.
+ *
+ * Creates an animation to Uncle enemy.
+ *
+ * @param path Path to the image which contains the sprite sheet.
+ * @param sprite_lines Number of the lines on the sprite sheet.
+ * @param sprite_colums Number of colums on the sprite sheet.
+ * @param duration Time duration of animation.
+ * @param direction Direction of animation.
+ * @return This method returns Uncle's animation.
+ */
+
+engine::Animation* Uncle::create_animation(
+	std::string path,
+  	int sprite_lines,
+  	int sprite_columns,
+  	double duration,
+  	std::string direction) {
+    DEBUG("Creating animations.");
+
+  	engine::Game& game = engine::Game::get_instance(); /**< Game.
+    Gets an instance of a game just initializated. */
+
+    engine::Animation* animation = nullptr; /**< Animation.
+    Can represents all functions about uncle's animation. */
+
+    /* Initializes uncle's animation object. */
+    animation = new engine::Animation(
+    	  game.get_renderer(),
+    	  path,
+    	  false,
+    	  std::make_pair(0, 0),
+    	  1,
+    	  sprite_lines,
+    	  sprite_columns,
+    	  duration,
+    	  true,
+    	  direction
+  	);
+
+    /* Sets values to init a initial position of animation on the screen.*/
+  	animation->set_values(
+    	  std::make_pair(320, 320),
+    	  std::make_pair(320, 320),
+    	  std::make_pair(0, 0)
+  	);
+
+    DEBUG("Animations created.");
+  	return animation;
+}
+
+/**
+ * @brief Initialize Uncle's animations.
+ *
+ * Define Uncle's movement and attack animation.
+ *
+ * @return void.
+ */
+
+void Uncle::initialize_animations() {
+    /* Starts debugger to accompany the method's development. */
+    DEBUG("Initializing animations.");
+
+  	engine::Animation* idle_animation = nullptr; /**< Animation.
+    Animation that represents uncle's in a idle state.s */
+
+    /* Creates uncle's idle animation. */
+    idle_animation = create_animation(
+      	"../assets/images/sprites/enemies/uncle/uncle_idle.png",
+      	1, 4, 3.0, "LEFT"
+    );
+
+    /* Sets uncle's idle animation to define when its stopped. */
+  	idle_animation->set_values(
+      	std::make_pair(665, 484),
+      	std::make_pair(665, 484),
+      	std::make_pair(0, 0)
+    );
+
+    add_animation("idle_animation",idle_animation);
+
+    idle_animation->activate();
+  	set_actual_animation(idle_animation);
+
+  	engine::Animation* attacking_animation = nullptr; /**< Animation.
+    Animation that represents uncle's attacking. */
+
+    /* Creates uncle's attack animation. */
+    attacking_animation = create_animation(
+     	"../assets/images/sprites/enemies/uncle/uncle_attacking.png",
+      	1, 1, 3.0, "LEFT"
+    );
+
+    /* Sets uncle's attacking animation to define when its attacking. */
+  	attacking_animation->set_values(
+      	std::make_pair(719, 523),
+      	std::make_pair(719, 523),
+      	std::make_pair(0, 0)
+    );
+
+  	attacking_animation->in_loop = false;
+
+   	add_animation("attacking_animation",attacking_animation);
+
+    /* Ends debugger that represents the end of the method. */
+    DEBUG("Animations initializated.");
+}
+
+/**
+ * @brief Initialize Uncle's hitboxes.
+ *
+ * Initializes Uncle instance hitboxes.
+ *
+ * @return void.
+ */
+
+void Uncle::initialize_hitboxes() {
+    /* Starts debugger to accompany the method's development. */
+    DEBUG("Initializing uncle's hitbox.");
+
+  	engine::Game& game = engine::Game::get_instance(); /**< Game.
+    Gets an instance of a game just initializated. */
+
+    engine::Hitbox* head_hitbox = nullptr; /**< Hitbox.
+    Initialize uncle's head hitbox. */
+
+    head_hitbox = new engine::Hitbox(
+    	  "head_hitbox",
+    	  this->get_position(),
+    	  std::make_pair(160, 380),
+    	  std::make_pair(180,20),
+    	  game.get_renderer()
+  	);
+
+    /* Add hitbox component into the game object. */
+  	add_component(head_hitbox);
+
+    /* Ends debugger that represents the end of the method. */
+    DEBUG("Uncle's hitbox initialized");
+}
+
+/**
+ * @brief Initialize Uncle's state map.
+ *
+ * Initialize all possibles states for the Uncle.
+ *
+ * @return void.
+ */
+
+void Uncle::initialize_state_map() {
+    /* Starts debugger to accompany the method's development. */
+    DEBUG("Initializing uncle's state.");
+  	states.set_state("ACTION_STATE","NORMAL");
+    /* Ends debugger that represents the end of the method. */
+    DEBUG("Uncle's state initialized.");
+}
+
+/**
+ * @brief Initialize uncle's audio effects.
+ *
+ * Not implemented.
+ *
+ * @return void.
+ */
+
+void Uncle::initialize_audio_effects() {
+}
+
+/**
+ * @brief Register game events.
+ *
+ * Register an event to Uncle.
+ *
+ * @param game_event Triggering in-game events.
+ * @return void.
+ */
+
+void Uncle::on_event(GameEvent game_event) {
+  	std::string event_name = ""; /**< String.
+    Gets an event catched by the Uncle. */
+
+    /* Gets event related with the Uncle. */
+    event_name = game_event.game_event_name;
+
+    /* Check if the Uncle gets an event to move to the left direction. */
+  	if (event_name == "MOVE_LEFT"
+  		&& !engine::GameObject::on_limit_of_level) {
+
+        /* The Uncle increments its actual position. */
+    	  set_position_x(get_position_x() + 10);
+  	}
+    /* Check if the Uncle gets an event to move to the right direction. */
+  	else if (event_name == "MOVE_RIGHT"
+  		&& !engine::GameObject::on_limit_of_level) {
+
+        /* The Uncle decrements its actual position. */
+    	  set_position_x(get_position_x() - 10);
+  	}
+    else {
+        /* Event name is not found. */
+    }
+}
+
+/**
+ * @brief Notify if the object is in the range.
+ *
+ * Notify if there is an object in the Uncle's range.
+ *
+ * @param game_object The game object passed in notification, in this case,
+ * the girl.
+ * @return void.
+ */
+
+void Uncle::notify(engine::Observable *game_object) {
+  	LittleGirl* little_girl = nullptr; /**< LittleGirl.
+    Gets as observable that tells when little_girl is next. */
+
+    little_girl = dynamic_cast<LittleGirl *>(game_object);
+
+    /* Notify if little_girl exists, moving to her direction. */
+    if (little_girl) {
+        /* The Uncle moves in direction of the girl. */
+      	attack(little_girl);
+  	}
+    else {
+        /* The Uncle don't attack. */
+    }
+}
+
+/**
+ * @brief Event for the collision.
+ *
+ * Method called everytime when two game objects collides.
+ *
+ * @param other Other game object that collides.
+ * @param p_my_hitbox Hitbox that receives the collision.
+ * @param p_other_hitbox Hitbox that collided.
+ * @return void.
+ */
+
+void Uncle::on_collision(
+	engine::GameObject* other,
+	engine::Hitbox* p_my_hitbox,
+	engine::Hitbox* p_other_hitbox) {
+  	LittleGirl* little_girl = nullptr; /**< LittleGirl.
+    References to LittleGirl object. */
+    little_girl = dynamic_cast<LittleGirl *>(other);
+
+  	engine::Hitbox* my_hitbox = nullptr; /**< Hitbox.
+    References to Uncle's hitbox. */
+    my_hitbox = dynamic_cast<engine::Hitbox *>(p_my_hitbox);
+
+  	engine::Hitbox* other_hitbox = nullptr; /**< Hitbox.
+    References to girl's hitbox. */
+    other_hitbox = dynamic_cast<engine::Hitbox *>(p_other_hitbox);
+
+    /* Check if the girl is attacking the Uncle. */
+  	if (little_girl
+  		&& little_girl->get_state("ACTION_STATE") == "ATTACKING"
+  		&& my_hitbox->get_name() == "head_hitbox"
+  		&& little_girl->get_actual_animation()->actual_column == 2
+     	&& get_state("X_STATE") != little_girl->get_state("X_STATE")) {
+
+          /* Check if the Uncle is under attack. */
+          if(get_state("ACTION_STATE") == "ON_ATTACK") {
+              return;
+          }
+          else {
+              on_attack(other);
+          }
+  	}
+    else {
+        /* The girl is not attacking the Uncle. */
+    }
+}
+
+/**
+ * @brief Define a basic attack.
+ *
+ * Method not implemented.
+ *
+ * @return void.
+ */
+
+void Uncle::basic_attack(){
+}
+
+/**
+ * @brief Uncle's attack.
+ *
+ * This method define Uncle's state while is attacking, is on attack or
+ * while is dying.
+ *
+ * @param little_girl Object to be attacked.
+ * @return void.
+ */
+
+void Uncle::attack(engine::GameObject* little_girl) {
+    DEBUG("The uncle is attacking.");
+
+  	std::string actual_action_state = ""; /**< String.
+    Gets the actual state of the uncle. */
+    actual_action_state = get_state("ACTION_STATE");
+
+  	if (actual_action_state == "DYING") {
+        INFO("The Uncle is dying.");
+    		return;
+  	}
+    else {
+        /* The Uncle stills alive. */
+    }
+
+  	if (actual_action_state == "ON_ATTACK"
+  		|| actual_action_state == "ATTACKING") {
+
+        if (get_actual_animation()->is_finished) {
+            states.set_state("ACTION_STATE","NORMAL");
+            set_actual_animation(animations["idle_animation"]);
+        }
+        else {
+            return;
+        }
+  	}
+    else {
+        /* The Uncle is in a idle state. */
+    }
+}
+
+/**
+ * @brief Define action when is on attack.
+ *
+ * Event called when Uncle is attacking.
+ *
+ * @param game_object Object to be attacked.
+ * @return void.
+ */
+
+void Uncle::on_attack(engine::GameObject *game_object) {
+  	states.set_state("ACTION_STATE","ON_ATTACK");
+
+  	hit(game_object, 1);
+  	if (is_alive()) {
+    	  set_actual_animation(animations["on_attack_animation"]);
+    	  //play_song("hit_me");
+  	}
+    else {
+        /* The Uncle is dead. */
+    }
+}
+
+/**
+ * @brief Death method.
+ *
+ * This method define an animation when Uncle is dead.
+ *
+ * @param game_object Uncle.
+ * @return void.
+ */
+
+void Uncle::die(engine::GameObject *game_object) {
+    DEBUG("The uncle is dying.");
+  	std::string actual_x_state = ""; /**< String.
+    Gets the actual state of the uncle. */
+    actual_x_state = get_state("X_STATE");
+    /* Sets a state that represents when uncle is dead. */
+    states.set_state("ACTION_STATE", "DYING");
+    /* Initiates the animation that show the uncle dying.*/
+  	set_actual_animation(animations["dying_animation"]);
+  	//play_song("hit_me");
+    DEBUG("The uncle died.");
+}

pool/shard006/C++/0083703_reportescuotas.cpp

@@ -0,0 +1,114 @@
+#include "reportescuotas.h"
+#include "EReporte.h"
+#include "mclientes.h"
+
+#include <QDate>
+#include <QMessageBox>
+#include <QInputDialog>
+
+
+/*!
+ * \brief ReportesCuotas::version
+ * \return
+ */
+double ReportesCuotas::version() const
+{ return 0.1; }
+
+/*!
+ * \brief ReportesCuotas::nombre
+ * \return
+ */
+QString ReportesCuotas::nombre() const
+{ return "ReportesCuotas"; }
+
+/*!
+ * \brief ReportesCuotas::inicializar
+ * \return
+ */
+bool ReportesCuotas::inicializar()
+{
+    ActResumenCuotasDeudaHistorica = new QAction( this );
+    ActResumenCuotasDeudaHistorica->setText( "Deuda historica" );
+    ActResumenCuotasDeudaHistorica->setStatusTip( "Muestra un resumen de los estados de todas las cuotas" );
+    ActResumenCuotasDeudaHistorica->setIcon( QIcon( ":/imagenes/resumen_cuotas.png" ) );
+    connect( ActResumenCuotasDeudaHistorica, SIGNAL( triggered() ), this, SLOT( resumenCuotasDeudaHistorica() ) );
+
+    ActResumenCuotasMes = new QAction( this );
+    ActResumenCuotasMes->setText( "Deuda en mes" );
+    ActResumenCuotasMes->setStatusTip( "Muestra el resumen de las cuotas del mes" );
+    connect( ActResumenCuotasMes, SIGNAL( triggered() ), this, SLOT( resumenCuotasMes() ) );
+
+    ActResumenCuotasCliente = new QAction( this );
+    ActResumenCuotasCliente->setText( "Deuda por cliente" );
+    ActResumenCuotasCliente->setStatusTip( "Muestra las deudas de un cliente especifico" );
+    connect( ActResumenCuotasCliente, SIGNAL( triggered() ), this, SLOT( resumenCuotasCliente() ) );
+
+    return true;
+}
+
+/*!
+ * \brief ReportesCuotas::hacerMenu
+ * \param m
+ */
+void ReportesCuotas::hacerMenu( QMenu *m )
+{
+    QMenu *menu = m->addMenu( "Cuotas" );
+    menu->addAction( ActResumenCuotasDeudaHistorica );
+    menu->addAction( ActResumenCuotasMes );
+    menu->addAction( ActResumenCuotasCliente );
+}
+
+/*!
+ * \brief ReportesCuotas::resumenCuotasDeudaHistorica
+ */
+void ReportesCuotas::resumenCuotasDeudaHistorica()
+{
+    EReporte *rep = new EReporte( 0 );
+    rep->especial( "CuotasHistoricas", ParameterList() );
+    rep->hacerPDF( ParameterList(), QString( "Deudas Cuotas al %1" ).arg( QDate::currentDate().toString( "dd-MM-yyyy" ) ) );
+    delete rep;
+}
+
+/*!
+ * \brief ReportesCuotas::resumenCuotasMes
+ */
+void ReportesCuotas::resumenCuotasMes()
+{
+    QMessageBox::information( 0, "Error", "No implementado" );
+    return;
+    bool ok = false;
+    QStringList meses;
+    meses << "Enero" << "Febrero" << "Marzo" << "Abril" << "Mayo" << "Junio" << "Julio" << "Agosto" << "Septiembre" << "Octubre" << "Noviembre" << "Diciembre";
+    QString mes = QInputDialog::getItem( 0, "Elija el mes", "Elija el mes:", meses, QDate::currentDate().month(), false, &ok );
+    if( ok ) {
+        EReporte *rep = new EReporte( 0 );
+        ParameterList lista;
+        lista.append( Parameter( "mes", meses.indexOf( mes ) ) );
+        rep->especial( "DeudaCuotasMes", lista );
+        rep->hacerPDF( ParameterList(), QString( "Deudas Cuotas del mes %1-%2" ).arg( mes ).arg( QDate::currentDate().toString( "yyyy" ) ) );
+        delete rep;
+    }
+}
+
+/*!
+ * \brief ReportesCuotas::resumenCuotasCliente
+ * Muestra el resumen de cuotas de un cliente específico
+ */
+void ReportesCuotas::resumenCuotasCliente()
+{
+    QMessageBox::information( 0, "Error", "No implementado" );
+    return;
+    /// @TODO: Implementar reporte de deuda segun cliente
+    EReporte *rep = new EReporte( 0 );
+    int id_cliente = 1;
+    ParameterList lista;
+    lista.append( "id_cliente", id_cliente );
+    rep->especial( "deudascuotascliente", lista );
+    rep->hacerPDF( ParameterList(),
+                   QString( "Deudas de Cuotas de %2 Al %1" )
+                   .arg( QDate::currentDate().toString( Qt::LocaleDate ) )
+                   .arg( MClientes::getRazonSocial( id_cliente ) ) );
+    delete rep;
+}
+
+Q_EXPORT_PLUGIN2( reportescuotas, ReportesCuotas )

pool/shard006/C++/0083704_Resource.cpp

@@ -0,0 +1,131 @@
+//
+// Copyright (c) 2008-2016 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "../Precompiled.h"
+
+#include "../Core/Profiler.h"
+#include "../IO/File.h"
+#include "../IO/Log.h"
+#include "../Resource/Resource.h"
+
+namespace Urho3D
+{
+
+Resource::Resource(Context* context) :
+    Object(context),
+    memoryUse_(0),
+    asyncLoadState_(ASYNC_DONE)
+{
+}
+
+bool Resource::Load(Deserializer& source)
+{
+    // Because BeginLoad() / EndLoad() can be called from worker threads, where profiling would be a no-op,
+    // create a type name -based profile block here
+#ifdef URHO3D_PROFILING
+    String profileBlockName("Load" + GetTypeName());
+
+    Profiler* profiler = GetSubsystem<Profiler>();
+    if (profiler)
+        profiler->BeginBlock(profileBlockName.CString());
+#endif
+
+    // If we are loading synchronously in a non-main thread, behave as if async loading (for example use
+    // GetTempResource() instead of GetResource() to load resource dependencies)
+    SetAsyncLoadState(Thread::IsMainThread() ? ASYNC_DONE : ASYNC_LOADING);
+    bool success = BeginLoad(source);
+    if (success)
+        success &= EndLoad();
+    SetAsyncLoadState(ASYNC_DONE);
+
+#ifdef URHO3D_PROFILING
+    if (profiler)
+        profiler->EndBlock();
+#endif
+
+    return success;
+}
+
+bool Resource::BeginLoad(Deserializer& source)
+{
+    // This always needs to be overridden by subclasses
+    return false;
+}
+
+bool Resource::EndLoad()
+{
+    // If no GPU upload step is necessary, no override is necessary
+    return true;
+}
+
+bool Resource::Save(Serializer& dest) const
+{
+    URHO3D_LOGERROR("Save not supported for " + GetTypeName());
+    return false;
+}
+
+bool Resource::Load(const String& fileName)
+{
+    File file(context_);
+    return file.Open(fileName, FILE_READ) && Load(file);
+}
+
+bool Resource::Save(const String& fileName) const
+{
+    File file(context_);
+    return file.Open(fileName, FILE_WRITE) && Save(file);
+}
+
+void Resource::SetName(const String& name)
+{
+    name_ = name;
+    nameHash_ = name;
+}
+
+void Resource::SetMemoryUse(unsigned size)
+{
+    memoryUse_ = size;
+}
+
+void Resource::ResetUseTimer()
+{
+    useTimer_.Reset();
+}
+
+void Resource::SetAsyncLoadState(AsyncLoadState newState)
+{
+    asyncLoadState_ = newState;
+}
+
+unsigned Resource::GetUseTimer()
+{
+    // If more references than the resource cache, return always 0 & reset the timer
+    if (Refs() > 1)
+    {
+        useTimer_.Reset();
+        return 0;
+    }
+    else
+        return useTimer_.GetMSec(false);
+}
+
+}

pool/shard006/C++/0083713_CWE78_OS_Command_Injection__char_console_w32_spawnvp_62a.cpp

@@ -0,0 +1,119 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE78_OS_Command_Injection__char_console_w32_spawnvp_62a.cpp
+Label Definition File: CWE78_OS_Command_Injection.strings.label.xml
+Template File: sources-sink-62a.tmpl.cpp
+*/
+/*
+ * @description
+ * CWE: 78 OS Command Injection
+ * BadSource: console Read input from the console
+ * GoodSource: Fixed string
+ * Sinks: w32_spawnvp
+ *    BadSink : execute command with spawnvp
+ * Flow Variant: 62 Data flow: data flows using a C++ reference from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#ifdef _WIN32
+#define COMMAND_INT_PATH "%WINDIR%\\system32\\cmd.exe"
+#define COMMAND_INT "cmd.exe"
+#define COMMAND_ARG1 "/c"
+#define COMMAND_ARG2 "dir"
+#define COMMAND_ARG3 data
+#else /* NOT _WIN32 */
+#include <unistd.h>
+#define COMMAND_INT_PATH "/bin/sh"
+#define COMMAND_INT "sh"
+#define COMMAND_ARG1 "ls"
+#define COMMAND_ARG2 "-la"
+#define COMMAND_ARG3 data
+#endif
+
+#include <process.h>
+
+namespace CWE78_OS_Command_Injection__char_console_w32_spawnvp_62
+{
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void badSource(char * &data);
+
+void bad()
+{
+    char * data;
+    char dataBuffer[100] = "";
+    data = dataBuffer;
+    badSource(data);
+    {
+        char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG2, COMMAND_ARG3, NULL};
+        /* spawnvp - searches for the location of the command among
+         * the directories specified by the PATH environment variable */
+        /* POTENTIAL FLAW: Execute command without validating input possibly leading to command injection */
+        _spawnvp(_P_WAIT, COMMAND_INT, args);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B uses the GoodSource with the BadSink */
+void goodG2BSource(char * &data);
+
+static void goodG2B()
+{
+    char * data;
+    char dataBuffer[100] = "";
+    data = dataBuffer;
+    goodG2BSource(data);
+    {
+        char *args[] = {COMMAND_INT_PATH, COMMAND_ARG1, COMMAND_ARG2, COMMAND_ARG3, NULL};
+        /* spawnvp - searches for the location of the command among
+         * the directories specified by the PATH environment variable */
+        /* POTENTIAL FLAW: Execute command without validating input possibly leading to command injection */
+        _spawnvp(_P_WAIT, COMMAND_INT, args);
+    }
+}
+
+void good()
+{
+    goodG2B();
+}
+
+#endif /* OMITGOOD */
+
+} /* close namespace */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+using namespace CWE78_OS_Command_Injection__char_console_w32_spawnvp_62; /* so that we can use good and bad easily */
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif

pool/shard006/C++/0083722_InstanceFleetTimeline.cpp

@@ -0,0 +1,96 @@
+/*
+* Copyright 2010-2017 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/elasticmapreduce/model/InstanceFleetTimeline.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace EMR
+{
+namespace Model
+{
+
+InstanceFleetTimeline::InstanceFleetTimeline() : 
+    m_creationDateTimeHasBeenSet(false),
+    m_readyDateTimeHasBeenSet(false),
+    m_endDateTimeHasBeenSet(false)
+{
+}
+
+InstanceFleetTimeline::InstanceFleetTimeline(JsonView jsonValue) : 
+    m_creationDateTimeHasBeenSet(false),
+    m_readyDateTimeHasBeenSet(false),
+    m_endDateTimeHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+InstanceFleetTimeline& InstanceFleetTimeline::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("CreationDateTime"))
+  {
+    m_creationDateTime = jsonValue.GetDouble("CreationDateTime");
+
+    m_creationDateTimeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ReadyDateTime"))
+  {
+    m_readyDateTime = jsonValue.GetDouble("ReadyDateTime");
+
+    m_readyDateTimeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("EndDateTime"))
+  {
+    m_endDateTime = jsonValue.GetDouble("EndDateTime");
+
+    m_endDateTimeHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue InstanceFleetTimeline::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_creationDateTimeHasBeenSet)
+  {
+   payload.WithDouble("CreationDateTime", m_creationDateTime.SecondsWithMSPrecision());
+  }
+
+  if(m_readyDateTimeHasBeenSet)
+  {
+   payload.WithDouble("ReadyDateTime", m_readyDateTime.SecondsWithMSPrecision());
+  }
+
+  if(m_endDateTimeHasBeenSet)
+  {
+   payload.WithDouble("EndDateTime", m_endDateTime.SecondsWithMSPrecision());
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace EMR
+} // namespace Aws

pool/shard006/C++/0083726_centered_continued_fraction.cpp

@@ -0,0 +1,51 @@
+//  (C) Copyright Nick Thompson 2020.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Deliberately contains some unicode characters:
+// 
+// boost-no-inspect
+//
+#include <iostream>
+#include <boost/math/constants/constants.hpp>
+#include <boost/math/tools/centered_continued_fraction.hpp>
+#include <boost/multiprecision/mpfr.hpp>
+
+using boost::math::constants::root_two;
+using boost::math::constants::phi;
+using boost::math::constants::pi;
+using boost::math::constants::e;
+using boost::math::constants::zeta_three;
+using boost::math::tools::centered_continued_fraction;
+using boost::multiprecision::mpfr_float;
+
+int main()
+{
+    using Real = mpfr_float;
+    int p = 10000;
+    mpfr_float::default_precision(p);
+    auto phi_cfrac = centered_continued_fraction(phi<Real>());
+    std::cout << "φ ≈ " << phi_cfrac << "\n";
+    std::cout << "Khinchin mean: " << std::setprecision(10) << phi_cfrac.khinchin_geometric_mean() << "\n\n\n";
+
+    auto pi_cfrac = centered_continued_fraction(pi<Real>());
+    std::cout << "π ≈ " << pi_cfrac << "\n";
+    std::cout << "Khinchin mean: " << std::setprecision(10) << pi_cfrac.khinchin_geometric_mean() << "\n\n\n";
+
+    auto rt_cfrac = centered_continued_fraction(root_two<Real>());
+    std::cout << "√2 ≈ " << rt_cfrac << "\n";
+    std::cout << "Khinchin mean: " << std::setprecision(10) <<  rt_cfrac.khinchin_geometric_mean() << "\n\n\n";
+
+    auto e_cfrac = centered_continued_fraction(e<Real>());
+    std::cout << "e ≈ " << e_cfrac << "\n";
+    std::cout << "Khinchin mean: " << std::setprecision(10) <<  e_cfrac.khinchin_geometric_mean() << "\n\n\n";
+
+    auto z_cfrac = centered_continued_fraction(zeta_three<Real>());
+    std::cout << "ζ(3) ≈ " << z_cfrac << "\n";
+    std::cout << "Khinchin mean: " << std::setprecision(10) <<  z_cfrac.khinchin_geometric_mean() << "\n\n\n";
+
+
+    // http://jeremiebourdon.free.fr/data/Khintchine.pdf
+    std::cout << "The expected Khinchin mean for a random centered continued fraction is 5.45451724454\n";
+}

pool/shard006/C++/0083728_main.cpp

@@ -0,0 +1,81 @@
+/**
+ * @file main.cpp
+ * @brief Main file.
+ * @author Michal Policht
+ */
+
+#include <QCoreApplication>
+#include <QString>
+#include <QTextStream>
+#include <QThread>
+#include <qextserialport.h>
+#include "PortListener.h"
+
+class SerialThread: public QThread
+{
+	QextSerialPort * port;
+	
+	protected:
+		virtual void run()
+		{
+			QString inStr;
+			QTextStream in(stdin);
+			QTextStream out(stdout);
+			
+			out << "Special commands: open close bye" << endl << endl;
+			while(inStr.compare("bye") != 0) {
+				in >> inStr;
+				if (inStr.compare("close") == 0) {
+					out << "requesting close... " << endl; 
+					port->close();
+				}
+				else if (inStr.compare("open") == 0) {
+					out << "opening port... ";
+					out << port->open(QIODevice::ReadWrite);
+					out << endl;
+				} else if (inStr.compare("bye") != 0)
+					port->write(inStr.toAscii().constData(), inStr.length());
+			}
+			port->close();
+		}
+	
+	public:
+		SerialThread(QextSerialPort * port, QObject * parent = 0):
+			QThread(parent)
+		{
+			this->port = port;
+		}
+}; 
+
+int main(int argc, char *argv[])
+{
+	QTextStream out(stdout);
+	QCoreApplication app(argc, argv);
+
+	QextSerialPort * port = new QextSerialPort("COM1", QextSerialPort::EventDriven);
+	port->setBaudRate(BAUD56000);
+	port->setFlowControl(FLOW_OFF);
+	port->setParity(PAR_NONE);
+	port->setDataBits(DATA_8);
+	port->setStopBits(STOP_2);
+	port->open(QIODevice::ReadWrite);
+	if (!(port->lineStatus() & LS_DSR)) {
+		out << "warning: device is not turned on" << endl;
+	}
+
+	PortListener * listener = new PortListener(port);
+	//Because port and listener are working in different threads 
+	//Qt will choose queued connection. This may produce clusters of 
+	//signals waiting in the queue.
+	listener->connect(port, SIGNAL(readyRead()), listener, SLOT(receive()));
+	listener->connect(port, SIGNAL(bytesWritten(qint64)), listener, SLOT(reportWritten(qint64)));
+	listener->connect(port, SIGNAL(aboutToClose()), listener, SLOT(reportClose()));
+	listener->connect(port, SIGNAL(dsrChanged(bool)), listener, SLOT(reportDsr(bool)));
+	
+	SerialThread * thread = new SerialThread(port);
+	app.connect(thread, SIGNAL(finished()), & app, SLOT(quit()));
+	thread->start();
+	
+	//event loop is required to utilize signals and slots mechanism 
+	return app.exec();
+}

pool/shard006/C++/0083732_bonus.cpp

@@ -0,0 +1,56 @@
+#include "bonus.h"
+
+/*!
+* Instanciates a bonus depending its type
+* @param type Type of bonus
+*/
+Bonus::Bonus(int type)
+{
+    setRect(10, 10, 5, 5);
+    m_type = type;
+    for (int i = 0; i < 4; i++) {
+	m_attributes.append(0);
+    }
+
+    switch(m_type) {
+    case BOMB_RANGE_UP:
+	if (qrand() % 2 == 1) {
+	    setBrush(QColor::fromRgb (255, 150, 0));
+	    m_attributes.insert(BOMB_RANGE_UP, -1);
+	} else {
+	    setBrush(Qt::red);
+	    m_attributes.insert(BOMB_RANGE_UP, 1);
+	}
+	break;
+    case BOMB_CAPACITY_UP:
+	if (qrand() % 2 == 1) {
+	    setBrush(Qt::cyan);
+	    m_attributes.insert(BOMB_CAPACITY_UP, -1);
+	} else {
+	    setBrush(Qt::blue);
+	    m_attributes.insert(BOMB_CAPACITY_UP, 1);
+	}
+	break;
+
+    case KICK_ACTIVATOR:
+	setBrush(Qt::darkMagenta);
+	m_attributes.insert(KICK_ACTIVATOR, 1);
+	break;
+    case LIFE_UP:
+	setBrush(Qt::green);
+	m_attributes.insert(LIFE_UP, 1);
+	break;
+    }
+}
+
+Bonus::~Bonus() {
+}
+
+int Bonus::type() {
+    return m_type;
+}
+
+QList<int> Bonus::attributes() {
+    return m_attributes;
+}
+

pool/shard006/C++/0083736_CEGUIOgreResourceProvider.cpp

@@ -0,0 +1,115 @@
+/************************************************************************
+    filename:   CEGUIOgreResourceProvider.cpp
+    created:    8/7/2004
+    author:     James '_mental_' O'Sullivan
+
+    purpose: Implements Ogre specific ResourceProvider
+*************************************************************************/
+/***************************************************************************
+ *   Copyright (C) 2004 - 2009 Paul D Turner & The CEGUI Development Team
+ *
+ *   Permission is hereby granted, free of charge, to any person obtaining
+ *   a copy of this software and associated documentation files (the
+ *   "Software"), to deal in the Software without restriction, including
+ *   without limitation the rights to use, copy, modify, merge, publish,
+ *   distribute, sublicense, and/or sell copies of the Software, and to
+ *   permit persons to whom the Software is furnished to do so, subject to
+ *   the following conditions:
+ *
+ *   The above copyright notice and this permission notice shall be
+ *   included in all copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ *   OTHER DEALINGS IN THE SOFTWARE.
+ ***************************************************************************/
+#include "CEGUIOgreResourceProvider.h"
+#include "CEGUIExceptions.h"
+
+#include <OgreArchiveManager.h>
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+//----------------------------------------------------------------------------//
+OgreResourceProvider::OgreResourceProvider()
+{
+    // set deafult resource group for Ogre
+    d_defaultResourceGroup =
+        Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str();
+}
+
+//----------------------------------------------------------------------------//
+void OgreResourceProvider::loadRawDataContainer(const String& filename,
+                                                RawDataContainer& output,
+                                                const String& resourceGroup)
+{
+    String orpGroup;
+    if (resourceGroup.empty())
+        orpGroup = d_defaultResourceGroup.empty() ?
+            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() :
+            d_defaultResourceGroup;
+    else
+        orpGroup = resourceGroup;
+
+    Ogre::DataStreamPtr input = Ogre::ResourceGroupManager::getSingleton().
+        openResource(filename.c_str(), orpGroup.c_str());
+
+    if (input.isNull())
+        CEGUI_THROW(InvalidRequestException(
+            "OgreCEGUIResourceProvider::loadRawDataContainer: Unable to open "
+            "resource file '" + filename + "' in resource group '" + orpGroup +
+            "'."));
+
+    Ogre::String buf = input->getAsString();
+    const size_t memBuffSize = buf.length();
+
+    unsigned char* mem = new unsigned char[memBuffSize];
+    memcpy(mem, buf.c_str(), memBuffSize);
+
+    output.setData(mem);
+    output.setSize(memBuffSize);
+}
+
+//----------------------------------------------------------------------------//
+void OgreResourceProvider::unloadRawDataContainer(RawDataContainer& data)
+{
+    if (data.getDataPtr())
+    {
+        delete[] data.getDataPtr();
+        data.setData(0);
+        data.setSize(0);
+    }
+}
+
+//----------------------------------------------------------------------------//
+size_t OgreResourceProvider::getResourceGroupFileNames(
+    std::vector<String>& out_vec, const String& file_pattern,
+    const String& resource_group)
+{
+    // get list of files in the group that match the pattern.
+    Ogre::StringVectorPtr vp =
+        Ogre::ResourceGroupManager::getSingleton().findResourceNames(
+            (resource_group.empty() ?
+                d_defaultResourceGroup.c_str() :
+                resource_group.c_str()),
+            file_pattern.c_str());
+
+    size_t entries = 0;
+    Ogre::StringVector::iterator i = vp->begin();
+    for (; i != vp->end(); ++i)
+    {
+        out_vec.push_back(*i);
+        ++entries;
+    }
+
+    return entries;
+}
+
+//----------------------------------------------------------------------------//
+
+} // End of  CEGUI namespace section

pool/shard006/C++/0083740_AssemblyContext.cpp

@@ -0,0 +1,88 @@
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "UnitSPIRV.h"
+
+#include <vector>
+#include <gmock/gmock.h>
+
+#include "source/instruction.h"
+
+using libspirv::AssemblyContext;
+using spvtest::AutoText;
+using spvtest::Concatenate;
+using ::testing::Eq;
+
+namespace {
+
+struct EncodeStringCase {
+  std::string str;
+  std::vector<uint32_t> initial_contents;
+};
+
+using EncodeStringTest = ::testing::TestWithParam<EncodeStringCase>;
+
+TEST_P(EncodeStringTest, Sample) {
+  AssemblyContext context(AutoText(""), nullptr);
+  spv_instruction_t inst;
+  inst.words = GetParam().initial_contents;
+  ASSERT_EQ(SPV_SUCCESS,
+            context.binaryEncodeString(GetParam().str.c_str(), &inst));
+  // We already trust MakeVector
+  EXPECT_THAT(inst.words,
+              Eq(Concatenate({GetParam().initial_contents,
+                              spvtest::MakeVector(GetParam().str)})));
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
+    BinaryEncodeString, EncodeStringTest,
+    ::testing::ValuesIn(std::vector<EncodeStringCase>{
+      // Use cases that exercise at least one to two words,
+      // and both empty and non-empty initial contents.
+      {"", {}},
+      {"", {1,2,3}},
+      {"a", {}},
+      {"a", {4}},
+      {"ab", {4}},
+      {"abc", {}},
+      {"abc", {18}},
+      {"abcd", {}},
+      {"abcd", {22}},
+      {"abcde", {4}},
+      {"abcdef", {}},
+      {"abcdef", {99,42}},
+      {"abcdefg", {}},
+      {"abcdefg", {101}},
+      {"abcdefgh", {}},
+      {"abcdefgh", {102, 103, 104}},
+      // A very long string, encoded after an initial word.
+      // SPIR-V limits strings to 65535 characters.
+      {std::string(65535, 'a'), {1}},
+    }),);
+// clang-format on
+
+}  // anonymous namespace

pool/shard006/C++/0083742_action_handler.cc

@@ -0,0 +1,85 @@
+// Copyright (c) 2019 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 <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/process/launch.h"
+#include "base/process/process.h"
+#include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/time/time.h"
+#include "chrome/updater/action_handler.h"
+#include "components/update_client/update_client.h"
+
+namespace updater {
+
+class ActionHandler : public update_client::ActionHandler {
+ public:
+  ActionHandler() = default;
+
+ private:
+  using Result =
+      std::tuple<bool /*succeeded*/, int /*error_code*/, int /*extra_code*/>;
+  ~ActionHandler() override = default;
+
+  // Overrides for update_client::ActionHandler.
+  void Handle(const base::FilePath& action,
+              const std::string& session_id,
+              Callback callback) override;
+
+  // For Windows, the action is a path to an EXE file.
+  static Result RunCommand(const base::FilePath& exe_path);
+
+  ActionHandler(const ActionHandler&) = delete;
+  ActionHandler& operator=(const ActionHandler&) = delete;
+};
+
+void ActionHandler::Handle(const base::FilePath& action,
+                           const std::string&,
+                           Callback callback) {
+  DCHECK(!action.empty());
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE,
+      {base::MayBlock(), base::WithBaseSyncPrimitives(),
+       base::TaskPriority::BEST_EFFORT,
+       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
+      base::BindOnce(&ActionHandler::RunCommand, action),
+      base::BindOnce(
+          [](Callback callback, const Result& result) {
+            auto [succeeded, error_code, extra_code] = result;
+            base::SequencedTaskRunnerHandle::Get()->PostTask(
+                FROM_HERE, base::BindOnce(std::move(callback), succeeded,
+                                          error_code, extra_code));
+          },
+          std::move(callback)));
+}
+
+ActionHandler::Result ActionHandler::RunCommand(
+    const base::FilePath& exe_path) {
+  base::CommandLine command_line(exe_path);
+  VLOG(1) << "run command: " << command_line.GetCommandLineString();
+  base::LaunchOptions options;
+  options.start_hidden = true;
+  base::Process process = base::LaunchProcess(command_line, options);
+  int exit_code = 0;
+  const base::TimeDelta kMaxWaitTime = base::Seconds(600);
+  const bool succeeded =
+      process.WaitForExitWithTimeout(kMaxWaitTime, &exit_code);
+  return Result{succeeded, exit_code, 0};
+}
+
+scoped_refptr<update_client::ActionHandler> MakeActionHandler() {
+  return base::MakeRefCounted<ActionHandler>();
+}
+
+}  // namespace updater

pool/shard006/C++/0083750_KernelRidgeRegression.cpp

@@ -0,0 +1,79 @@
+/**
+ * @file
+ * @copyright This code is licensed under the 3-clause BSD license.\n
+ *            Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.\n
+ *            See LICENSE.txt for details.
+ */
+
+#include "KernelRidgeRegression.h"
+
+namespace Scine {
+namespace Utils {
+namespace MachineLearning {
+
+void KernelRidgeRegression::trainModel(const Eigen::MatrixXd& featureValues, const Eigen::MatrixXd& targetValues) {
+  if (targetValues.rows() != featureValues.rows())
+    throw std::runtime_error("The number of data points do not match between the feature and target matrices.");
+
+  // Transpose the feature and target matrices since they are column-major.
+  targetValues_ = targetValues.transpose();
+  featureValues_ = featureValues.transpose();
+  numDataPoints_ = static_cast<int>(targetValues_.cols());
+
+  // Construct the kernel matrix
+  Eigen::MatrixXd kernelMatrix(numDataPoints_, numDataPoints_);
+#pragma omp parallel for schedule(dynamic)
+  for (int i = 0; i < numDataPoints_; ++i) {
+    for (int j = i; j < numDataPoints_; ++j) {
+      double value = kernel_(featureValues_.col(i), featureValues_.col(j), hyperparameters_);
+      kernelMatrix(i, j) = value;
+    }
+  }
+
+  kernelMatrix = kernelMatrix.selfadjointView<Eigen::Upper>();
+
+  // Inversion of the regularized kernel matrix
+  Eigen::MatrixXd identity = Eigen::MatrixXd::Identity(kernelMatrix.rows(), kernelMatrix.cols());
+  Eigen::MatrixXd regularizedKernelMatrix = kernelMatrix + regularizationFactor_ * identity;
+  invertedRegularizedKernelMatrix_ = regularizedKernelMatrix.inverse();
+}
+
+Eigen::VectorXd KernelRidgeRegression::predict(const Eigen::VectorXd& data) const {
+  if (invertedRegularizedKernelMatrix_.size() == 0)
+    throw std::runtime_error("The model has not been trained yet!");
+
+  // Calculate kernel vector
+  Eigen::VectorXd kernelVector(numDataPoints_);
+#pragma omp parallel for schedule(dynamic)
+  for (int i = 0; i < numDataPoints_; ++i) {
+    kernelVector(i) = kernel_(featureValues_.col(i), data, hyperparameters_);
+  }
+
+  // Calculate and return prediction
+  Eigen::MatrixXd kernelProduct = invertedRegularizedKernelMatrix_ * kernelVector;
+  Eigen::VectorXd prediction = targetValues_ * kernelProduct;
+
+  for (int k = 0; k < prediction.size(); ++k) {
+    if (std::isnan(prediction(k)))
+      throw std::runtime_error(
+          "One of the predicted results could not be obtained. The reason is probably that the regularization factor "
+          "is too small and therefore causes problems during the inversion of the kernel matrix.");
+  }
+
+  return prediction;
+}
+
+void KernelRidgeRegression::setRegularizationFactor(double factor) {
+  regularizationFactor_ = factor;
+}
+
+void KernelRidgeRegression::setKernel(
+    std::function<double(const Eigen::VectorXd&, const Eigen::VectorXd&, const std::vector<double>&)> kernel,
+    std::vector<double> hyperparameters) {
+  kernel_ = std::move(kernel);
+  hyperparameters_ = hyperparameters;
+}
+
+} // namespace MachineLearning
+} // namespace Utils
+} // namespace Scine

pool/shard006/C++/0083752_boss_ambassador_hellmaw.cpp

@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2008-2019 TrinityCore <https://www.trinitycore.org/>
+ * Copyright (C) 2006-2009 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* ScriptData
+SDName: Boss_Ambassador_Hellmaw
+SD%Complete: 80
+SDComment: Enrage spell missing/not known
+SDCategory: Auchindoun, Shadow Labyrinth
+EndScriptData */
+
+#include "ScriptMgr.h"
+#include "InstanceScript.h"
+#include "ScriptedEscortAI.h"
+#include "shadow_labyrinth.h"
+
+enum Yells
+{
+    SAY_INTRO       = 0,
+    SAY_AGGRO       = 1,
+    SAY_HELP        = 2,
+    SAY_SLAY        = 3,
+    SAY_DEATH       = 4
+};
+
+enum Spells
+{
+    SPELL_BANISH            = 30231,
+    SPELL_CORROSIVE_ACID    = 33551,
+    SPELL_FEAR              = 33547,
+    SPELL_ENRAGE            = 34970
+};
+
+enum Events
+{
+    EVENT_CORROSIVE_ACID = 1,
+    EVENT_FEAR,
+    EVENT_BERSERK
+};
+
+class boss_ambassador_hellmaw : public CreatureScript
+{
+    public:
+        boss_ambassador_hellmaw() : CreatureScript("boss_ambassador_hellmaw") { }
+
+        struct boss_ambassador_hellmawAI : public npc_escortAI
+        {
+            boss_ambassador_hellmawAI(Creature* creature) : npc_escortAI(creature)
+            {
+                _instance = creature->GetInstanceScript();
+                _intro = false;
+            }
+
+            void Reset() override
+            {
+                if (!me->IsAlive())
+                    return;
+
+                _events.Reset();
+                _instance->SetBossState(DATA_AMBASSADOR_HELLMAW, NOT_STARTED);
+
+                _events.ScheduleEvent(EVENT_CORROSIVE_ACID, urand(5000, 10000));
+                _events.ScheduleEvent(EVENT_FEAR, urand(25000, 30000));
+                if (IsHeroic())
+                    _events.ScheduleEvent(EVENT_BERSERK, 180000);
+
+                DoAction(ACTION_AMBASSADOR_HELLMAW_BANISH);
+            }
+
+            void MoveInLineOfSight(Unit* who) override
+            {
+                if (me->HasAura(SPELL_BANISH))
+                    return;
+
+                npc_escortAI::MoveInLineOfSight(who);
+            }
+
+            void WaypointReached(uint32 /*waypointId*/) override
+            {
+            }
+
+            void DoAction(int32 actionId) override
+            {
+                if (actionId == ACTION_AMBASSADOR_HELLMAW_INTRO)
+                    DoIntro();
+                else if (actionId == ACTION_AMBASSADOR_HELLMAW_BANISH)
+                {
+                    if (_instance->GetData(DATA_FEL_OVERSEER) && me->HasAura(SPELL_BANISH))
+                        DoCast(me, SPELL_BANISH, true); // this will not work, because he is immune to banish
+                }
+            }
+
+            void DoIntro()
+            {
+                if (_intro)
+                    return;
+
+                _intro = true;
+
+                if (me->HasAura(SPELL_BANISH))
+                    me->RemoveAurasDueToSpell(SPELL_BANISH);
+
+                Talk(SAY_INTRO);
+                Start(true, false, ObjectGuid::Empty, NULL, false, true);
+            }
+
+            void EnterCombat(Unit* /*who*/) override
+            {
+                _instance->SetBossState(DATA_AMBASSADOR_HELLMAW, IN_PROGRESS);
+                Talk(SAY_AGGRO);
+            }
+
+            void KilledUnit(Unit* who) override
+            {
+                if (who->GetTypeId() == TYPEID_PLAYER)
+                    Talk(SAY_SLAY);
+            }
+
+            void JustDied(Unit* /*killer*/) override
+            {
+                _instance->SetBossState(DATA_AMBASSADOR_HELLMAW, DONE);
+                Talk(SAY_DEATH);
+            }
+
+            void UpdateEscortAI(uint32 diff) override
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (me->HasAura(SPELL_BANISH))
+                {
+                    EnterEvadeMode(EVADE_REASON_OTHER);
+                    return;
+                }
+
+                _events.Update(diff);
+
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
+
+                while (uint32 eventId = _events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_CORROSIVE_ACID:
+                            DoCastVictim(SPELL_CORROSIVE_ACID);
+                            _events.ScheduleEvent(EVENT_CORROSIVE_ACID, urand(15000, 25000));
+                            break;
+                        case EVENT_FEAR:
+                            DoCastAOE(SPELL_FEAR);
+                            _events.ScheduleEvent(EVENT_FEAR, urand(20000, 35000));
+                            break;
+                        case EVENT_BERSERK:
+                            DoCast(me, SPELL_ENRAGE, true);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                DoMeleeAttackIfReady();
+            }
+
+        private:
+            InstanceScript* _instance;
+            EventMap _events;
+            bool _intro;
+        };
+
+        CreatureAI* GetAI(Creature* creature) const override
+        {
+            return GetShadowLabyrinthAI<boss_ambassador_hellmawAI>(creature);
+        }
+};
+
+void AddSC_boss_ambassador_hellmaw()
+{
+    new boss_ambassador_hellmaw();
+}

pool/shard006/C++/0083759_PersistentParserState.cpp

@@ -0,0 +1,88 @@
+//===--- PersistentParserState.cpp - Parser State Implementation ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements parser state persistent across multiple parses.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/Decl.h"
+#include "swift/AST/Expr.h"
+#include "swift/Parse/PersistentParserState.h"
+
+using namespace swift;
+
+void PersistentParserState::delayFunctionBodyParsing(AbstractFunctionDecl *AFD,
+                                                     SourceRange BodyRange,
+                                                     SourceLoc PreviousLoc) {
+  std::unique_ptr<FunctionBodyState> State;
+  State.reset(new FunctionBodyState(BodyRange, PreviousLoc,
+                                    ScopeInfo.saveCurrentScope()));
+  assert(DelayedFunctionBodies.find(AFD) == DelayedFunctionBodies.end() &&
+         "Already recorded state for this body");
+  DelayedFunctionBodies[AFD] = std::move(State);
+}
+
+std::unique_ptr<PersistentParserState::FunctionBodyState>
+PersistentParserState::takeFunctionBodyState(AbstractFunctionDecl *AFD) {
+  assert(AFD->getBodyKind() == AbstractFunctionDecl::BodyKind::Unparsed);
+  DelayedFunctionBodiesTy::iterator I = DelayedFunctionBodies.find(AFD);
+  assert(I != DelayedFunctionBodies.end() && "State should be saved");
+  std::unique_ptr<FunctionBodyState> State = std::move(I->second);
+  DelayedFunctionBodies.erase(I);
+  return State;
+}
+
+bool PersistentParserState::hasFunctionBodyState(AbstractFunctionDecl *AFD) {
+  return DelayedFunctionBodies.find(AFD) != DelayedFunctionBodies.end();
+}
+
+void PersistentParserState::delayAccessorBodyParsing(AbstractFunctionDecl *AFD,
+                                                     SourceRange BodyRange,
+                                                     SourceLoc PreviousLoc,
+                                                     SourceLoc LBLoc) {
+  std::unique_ptr<AccessorBodyState> State;
+  State.reset(new AccessorBodyState(BodyRange, PreviousLoc,
+                                    ScopeInfo.saveCurrentScope(), LBLoc));
+  assert(DelayedAccessorBodies.find(AFD) == DelayedAccessorBodies.end() &&
+         "Already recorded state for this body");
+  DelayedAccessorBodies[AFD] = std::move(State);
+}
+
+std::unique_ptr<PersistentParserState::AccessorBodyState>
+PersistentParserState::takeAccessorBodyState(AbstractFunctionDecl *AFD) {
+  assert(AFD->getBodyKind() == AbstractFunctionDecl::BodyKind::Unparsed);
+  DelayedAccessorBodiesTy::iterator I = DelayedAccessorBodies.find(AFD);
+  assert(I != DelayedAccessorBodies.end() && "State should be saved");
+  std::unique_ptr<AccessorBodyState> State = std::move(I->second);
+  DelayedAccessorBodies.erase(I);
+  return State;
+}
+
+void PersistentParserState::delayDecl(DelayedDeclKind Kind,
+                                      unsigned Flags,
+                                      DeclContext *ParentContext,
+                                      SourceRange BodyRange,
+                                      SourceLoc PreviousLoc) {
+  assert(!CodeCompletionDelayedDeclState.get() &&
+         "only one decl can be delayed for code completion");
+  CodeCompletionDelayedDeclState.reset(new DelayedDeclState(
+      Kind, Flags, ParentContext, BodyRange, PreviousLoc,
+      ScopeInfo.saveCurrentScope()));
+}
+
+void PersistentParserState::delayTopLevel(TopLevelCodeDecl *TLCD,
+                                          SourceRange BodyRange,
+                                          SourceLoc PreviousLoc) {
+  delayDecl(DelayedDeclKind::TopLevelCodeDecl, 0U, TLCD, BodyRange,
+            PreviousLoc);
+}
+

pool/shard006/C++/0083769_mysql_remap.cc

@@ -0,0 +1,251 @@
+/*
+  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.
+*/
+
+#include <ts/ts.h>
+#include <ts/remap.h>
+#include <cstdio>
+#include <unistd.h>
+
+#include <mysql/mysql.h>
+
+#include "lib/iniparser.h"
+#include "default.h"
+
+MYSQL mysql;
+
+typedef struct {
+  char *query;
+} my_data;
+
+bool
+do_mysql_remap(TSCont contp, TSHttpTxn txnp)
+{
+  TSMBuffer reqp;
+  TSMLoc hdr_loc, url_loc, field_loc;
+  bool ret_val = false;
+
+  const char *request_host;
+  int request_host_length = 0;
+  const char *request_scheme;
+  int request_scheme_length = 0;
+  int request_port          = 80;
+  char *query;
+
+  MYSQL_ROW row;
+  MYSQL_RES *res;
+
+  my_data *data = static_cast<my_data *>(TSContDataGet(contp));
+  query         = data->query;
+
+  if (TSHttpTxnClientReqGet(txnp, &reqp, &hdr_loc) != TS_SUCCESS) {
+    TSDebug(PLUGIN_NAME, "could not get request data");
+    return false;
+  }
+
+  TSHttpHdrUrlGet(reqp, hdr_loc, &url_loc);
+
+  if (!url_loc) {
+    TSDebug(PLUGIN_NAME, "couldn't retrieve request url");
+    goto release_hdr;
+  }
+
+  field_loc = TSMimeHdrFieldFind(reqp, hdr_loc, TS_MIME_FIELD_HOST, TS_MIME_LEN_HOST);
+
+  if (!field_loc) {
+    TSDebug(PLUGIN_NAME, "couldn't retrieve request HOST header");
+    goto release_url;
+  }
+
+  request_host = TSMimeHdrFieldValueStringGet(reqp, hdr_loc, field_loc, -1, &request_host_length);
+  if (!request_host_length) {
+    TSDebug(PLUGIN_NAME, "couldn't find request HOST header");
+    goto release_field;
+  }
+
+  request_scheme = TSUrlSchemeGet(reqp, url_loc, &request_scheme_length);
+  request_port   = TSUrlPortGet(reqp, url_loc);
+
+  TSDebug(PLUGIN_NAME, "      +++++MYSQL REMAP+++++      ");
+
+  TSDebug(PLUGIN_NAME, "\nINCOMING REQUEST ->\n ::: from_scheme_desc: %.*s\n ::: from_hostname: %.*s\n ::: from_port: %d",
+          request_scheme_length, request_scheme, request_host_length, request_host, request_port);
+
+  snprintf(query, QSIZE, " \
+    SELECT \
+        t_scheme.scheme_desc, \
+        t_host.hostname, \
+        to_port \
+      FROM map \
+        INNER JOIN scheme as t_scheme ON (map.to_scheme_id = t_scheme.id) \
+        INNER JOIN scheme as f_scheme ON (map.from_scheme_id = f_scheme.id) \
+        INNER JOIN hostname as t_host ON (map.to_hostname_id = t_host.id) \
+        INNER JOIN hostname as f_host ON (map.from_hostname_id = f_host.id) \
+      WHERE \
+        is_enabled=1 \
+        AND f_host.hostname = '%.*s' \
+        AND f_scheme.id = %d \
+        AND from_port = %d \
+      LIMIT 1",
+           request_host_length, request_host, (strcmp(request_scheme, "https") == 0) ? 2 : 1, request_port);
+
+  mysql_real_query(&mysql, query, (unsigned int)strlen(query));
+  res = mysql_use_result(&mysql);
+
+  if (!res)
+    goto not_found; // TODO: define a fallback
+
+  do {
+    row = mysql_fetch_row(res);
+    if (!row)
+      goto not_found;
+    TSDebug(PLUGIN_NAME, "\nOUTGOING REQUEST ->\n ::: to_scheme_desc: %s\n ::: to_hostname: %s\n ::: to_port: %s", row[0], row[1],
+            row[2]);
+    TSMimeHdrFieldValueStringSet(reqp, hdr_loc, field_loc, 0, row[1], -1);
+    TSUrlHostSet(reqp, url_loc, row[1], -1);
+    TSUrlSchemeSet(reqp, url_loc, row[0], -1);
+    TSUrlPortSet(reqp, url_loc, atoi(row[2]));
+  } while (false);
+
+  ret_val = true;
+
+not_found:
+  if (!ret_val) {
+    // lets build up a nice 404 message for someone
+    TSHttpHdrStatusSet(reqp, hdr_loc, TS_HTTP_STATUS_NOT_FOUND);
+    TSHttpTxnStatusSet(txnp, TS_HTTP_STATUS_NOT_FOUND);
+  }
+  if (res)
+    mysql_free_result(res);
+#if (TS_VERSION_NUMBER < 2001005)
+  if (request_host)
+    TSHandleStringRelease(reqp, hdr_loc, request_host);
+  if (request_scheme)
+    TSHandleStringRelease(reqp, hdr_loc, request_scheme);
+#endif
+release_field:
+  if (field_loc) {
+    TSHandleMLocRelease(reqp, hdr_loc, field_loc);
+  }
+release_url:
+  if (url_loc) {
+    TSHandleMLocRelease(reqp, hdr_loc, url_loc);
+  }
+release_hdr:
+  if (hdr_loc) {
+    TSHandleMLocRelease(reqp, TS_NULL_MLOC, hdr_loc);
+  }
+
+  return ret_val;
+}
+
+static int
+mysql_remap(TSCont contp, TSEvent event, void *edata)
+{
+  TSHttpTxn txnp   = static_cast<TSHttpTxn>(edata);
+  TSEvent reenable = TS_EVENT_HTTP_CONTINUE;
+
+  switch (event) {
+  case TS_EVENT_HTTP_READ_REQUEST_HDR:
+    TSDebug(PLUGIN_NAME, "Reading Request");
+    TSSkipRemappingSet(txnp, 1);
+    if (!do_mysql_remap(contp, txnp)) {
+      reenable = TS_EVENT_HTTP_ERROR;
+    }
+    break;
+  default:
+    break;
+  }
+
+  TSHttpTxnReenable(txnp, reenable);
+  return 1;
+}
+
+void
+TSPluginInit(int argc, const char *argv[])
+{
+  dictionary *ini;
+  const char *host;
+  int port;
+  const char *username;
+  const char *password;
+  const char *db;
+
+  my_data *data = static_cast<my_data *>(malloc(1 * sizeof(my_data)));
+
+  TSPluginRegistrationInfo info;
+  bool reconnect = true;
+
+  info.plugin_name   = const_cast<char *>(PLUGIN_NAME);
+  info.vendor_name   = const_cast<char *>("Apache Software Foundation");
+  info.support_email = const_cast<char *>("dev@trafficserver.apache.org");
+
+  if (TSPluginRegister(&info) != TS_SUCCESS) {
+    TSError("[mysql_remap] Plugin registration failed");
+  }
+
+  if (argc != 2) {
+    TSError("[mysql_remap] Usage: %s /path/to/sample.ini", argv[0]);
+    return;
+  }
+
+  ini = iniparser_load(argv[1]);
+  if (!ini) {
+    TSError("[mysql_remap] Error with ini file (1)");
+    TSDebug(PLUGIN_NAME, "Error parsing ini file(1)");
+    return;
+  }
+
+  host     = iniparser_getstring(ini, "mysql_remap:mysql_host", (char *)"localhost");
+  port     = iniparser_getint(ini, "mysql_remap:mysql_port", 3306);
+  username = iniparser_getstring(ini, "mysql_remap:mysql_username", nullptr);
+  password = iniparser_getstring(ini, "mysql_remap:mysql_password", nullptr);
+  db       = iniparser_getstring(ini, "mysql_remap:mysql_database", (char *)"mysql_remap");
+
+  if (mysql_library_init(0, NULL, NULL)) {
+    TSError("[mysql_remap] Error initializing mysql client library");
+    TSDebug(PLUGIN_NAME, "Error initializing mysql client library");
+    return;
+  }
+
+  if (!mysql_init(&mysql)) {
+    TSError("[mysql_remap] Could not initialize MySQL");
+    TSDebug(PLUGIN_NAME, "Could not initialize MySQL");
+    return;
+  }
+
+  mysql_options(&mysql, MYSQL_OPT_RECONNECT, &reconnect);
+
+  if (!mysql_real_connect(&mysql, host, username, password, db, port, NULL, 0)) {
+    TSError("[mysql_remap] Could not connect to mysql");
+    TSDebug(PLUGIN_NAME, "Could not connect to mysql: %s", mysql_error(&mysql));
+    return;
+  }
+
+  data->query = static_cast<char *>(TSmalloc(QSIZE * sizeof(char))); // TODO: malloc smarter sizes
+
+  TSDebug(PLUGIN_NAME, "h: %s; u: %s; p: %s; p:%d; d:%s", host, username, password, port, db);
+  TSCont cont = TSContCreate(mysql_remap, TSMutexCreate());
+
+  TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont);
+
+  TSContDataSet(cont, (void *)data);
+
+  TSDebug(PLUGIN_NAME, "plugin is successfully initialized [plugin mode]");
+  iniparser_freedict(ini);
+  return;
+}

pool/shard006/C++/0083771_DumpMassCharge.cpp

@@ -0,0 +1,203 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2015-2020 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#include "core/ActionAtomistic.h"
+#include "core/ActionPilot.h"
+#include "core/ActionRegister.h"
+#include "tools/File.h"
+#include "core/PlumedMain.h"
+#include "core/Atoms.h"
+
+using namespace std;
+
+namespace PLMD
+{
+namespace generic {
+
+//+PLUMEDOC PRINTANALYSIS DUMPMASSCHARGE
+/*
+Dump masses and charges on a selected file.
+
+This command dumps a file containing charges and masses.
+It does so only once in the simulation (at first step).
+File can be recycled in the \ref driver tool.
+
+Notice that masses and charges are only written once at the beginning
+of the simulation. In case no atom list is provided, charges and
+masses for all atoms are written.
+
+\par Examples
+
+You can add the DUMPMASSCHARGE action at the end of the plumed.dat
+file that you use during an MD simulations:
+
+\plumedfile
+c1: COM ATOMS=1-10
+c2: COM ATOMS=11-20
+DUMPATOMS ATOMS=c1,c2 FILE=coms.xyz STRIDE=100
+
+DUMPMASSCHARGE FILE=mcfile
+\endplumedfile
+
+In this way, you will be able to use the same masses while processing
+a trajectory from the \ref driver . To do so, you need to
+add the --mc flag on the driver command line, e.g.
+\verbatim
+plumed driver --mc mcfile --plumed plumed.dat --ixyz traj.xyz
+\endverbatim
+
+With the following input you can dump only the charges for a specific
+group.
+\plumedfile
+solute_ions: GROUP ATOMS=1-121,200-2012
+DUMPATOMS FILE=traj.gro ATOMS=solute_ions STRIDE=100
+DUMPMASSCHARGE FILE=mcfile ATOMS=solute_ions
+\endplumedfile
+Notice however that if you want to process the charges
+with the driver (e.g. reading traj.gro) you have to fix atom
+numbers first, e.g. with the script
+\verbatim
+awk 'BEGIN{c=0}{
+  if(match($0,"#")) print ; else {print c,$2,$3; c++}
+}' < mc > newmc
+}'
+\endverbatim
+then
+\verbatim
+plumed driver --mc newmc --plumed plumed.dat --ixyz traj.gro
+\endverbatim
+
+
+*/
+//+ENDPLUMEDOC
+
+class DumpMassCharge:
+  public ActionAtomistic,
+  public ActionPilot
+{
+  string file;
+  bool first;
+  bool second;
+  bool print_masses;
+  bool print_charges;
+public:
+  explicit DumpMassCharge(const ActionOptions&);
+  ~DumpMassCharge();
+  static void registerKeywords( Keywords& keys );
+  void prepare() override;
+  void calculate() override {}
+  void apply() override {}
+  void update() override;
+};
+
+PLUMED_REGISTER_ACTION(DumpMassCharge,"DUMPMASSCHARGE")
+
+void DumpMassCharge::registerKeywords( Keywords& keys ) {
+  Action::registerKeywords( keys );
+  ActionPilot::registerKeywords( keys );
+  ActionAtomistic::registerKeywords( keys );
+  keys.add("compulsory","STRIDE","1","the frequency with which the atoms should be output");
+  keys.add("atoms", "ATOMS", "the atom indices whose charges and masses you would like to print out");
+  keys.add("compulsory", "FILE", "file on which to output charges and masses.");
+  keys.addFlag("ONLY_MASSES",false,"Only output masses to file");
+  keys.addFlag("ONLY_CHARGES",false,"Only output charges to file");
+}
+
+DumpMassCharge::DumpMassCharge(const ActionOptions&ao):
+  Action(ao),
+  ActionAtomistic(ao),
+  ActionPilot(ao),
+  first(true),
+  second(true),
+  print_masses(true),
+  print_charges(true)
+{
+  vector<AtomNumber> atoms;
+  parse("FILE",file);
+  if(file.length()==0) error("name of output file was not specified");
+  log.printf("  output written to file %s\n",file.c_str());
+
+  parseAtomList("ATOMS",atoms);
+
+  if(atoms.size()==0) {
+    for(int i=0; i<plumed.getAtoms().getNatoms(); i++) {
+      atoms.push_back(AtomNumber::index(i));
+    }
+  }
+
+  bool only_masses = false;
+  parseFlag("ONLY_MASSES",only_masses);
+  if(only_masses) {
+    print_charges = false;
+    log.printf("  only masses will be written to file\n");
+  }
+
+  bool only_charges = false;
+  parseFlag("ONLY_CHARGES",only_charges);
+  if(only_charges) {
+    print_masses = false;
+    log.printf("  only charges will be written to file\n");
+  }
+
+
+  checkRead();
+
+  log.printf("  printing the following atoms:" );
+  for(unsigned i=0; i<atoms.size(); ++i) log.printf(" %d",atoms[i].serial() );
+  log.printf("\n");
+  requestAtoms(atoms);
+
+  if(only_masses && only_charges) {
+    plumed_merror("using both ONLY_MASSES and ONLY_CHARGES doesn't make sense");
+  }
+
+}
+
+void DumpMassCharge::prepare() {
+  if(!first && second) {
+    requestAtoms(vector<AtomNumber>());
+    second=false;
+  }
+}
+
+void DumpMassCharge::update() {
+  if(!first) return;
+  first=false;
+
+  OFile of;
+  of.link(*this);
+  of.open(file);
+
+  for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+    int ii=getAbsoluteIndex(i).index();
+    of.printField("index",ii);
+    if(print_masses) {of.printField("mass",getMass(i));}
+    if(print_charges) {of.printField("charge",getCharge(i));}
+    of.printField();
+  }
+}
+
+DumpMassCharge::~DumpMassCharge() {
+}
+
+
+}
+}

pool/shard006/C++/0083773_desktop_screen_position_client.cc

@@ -0,0 +1,65 @@
+// Copyright (c) 2012 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 "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
+
+#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
+
+namespace views {
+
+namespace {
+
+// Returns true if bounds passed to window in SetBounds should be treated as
+// though they are in screen coordinates.
+bool PositionWindowInScreenCoordinates(aura::Window* window) {
+  if (window->type() == ui::wm::WINDOW_TYPE_POPUP)
+    return true;
+
+  Widget* widget = Widget::GetWidgetForNativeView(window);
+  return widget && widget->is_top_level();
+}
+
+}  // namespace
+
+DesktopScreenPositionClient::DesktopScreenPositionClient(
+    aura::Window* root_window)
+    : wm::DefaultScreenPositionClient(), root_window_(root_window) {
+  aura::client::SetScreenPositionClient(root_window_, this);
+}
+
+DesktopScreenPositionClient::~DesktopScreenPositionClient() {
+  aura::client::SetScreenPositionClient(root_window_, NULL);
+}
+
+void DesktopScreenPositionClient::SetBounds(aura::Window* window,
+                                            const gfx::Rect& bounds,
+                                            const gfx::Display& display) {
+  // TODO(jam): Use the 3rd parameter, |display|.
+  aura::Window* root = window->GetRootWindow();
+
+  // This method assumes that |window| does not have an associated
+  // DesktopNativeWidgetAura.
+  internal::NativeWidgetPrivate* desktop_native_widget =
+      DesktopNativeWidgetAura::ForWindow(root);
+  DCHECK(!desktop_native_widget ||
+         desktop_native_widget->GetNativeView() != window);
+
+  if (PositionWindowInScreenCoordinates(window)) {
+    // The caller expects windows we consider "embedded" to be placed in the
+    // screen coordinate system. So we need to offset the root window's
+    // position (which is in screen coordinates) from these bounds.
+
+    gfx::Point origin = bounds.origin();
+    aura::Window::ConvertPointToTarget(window->parent(), root, &origin);
+
+    gfx::Point host_origin = GetOriginInScreen(root);
+    origin.Offset(-host_origin.x(), -host_origin.y());
+    window->SetBounds(gfx::Rect(origin, bounds.size()));
+    return;
+  }
+
+  window->SetBounds(bounds);
+}
+
+}  // namespace views

pool/shard006/C++/0083780_a.cc

@@ -0,0 +1,67 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+class MyClass {
+
+private:
+    string name;
+
+public:
+    MyClass (string s) :name(s) {}
+    ~MyClass() {
+        cout << "Destroying " << name << endl;
+    }
+};
+
+void fa();
+void fb();
+void fc();
+void fd();
+
+int main() {
+
+    try {
+
+        MyClass mainObj("M");
+        fa();
+        cout << "Mission accomplished!\n";
+
+    } catch (const char *e) {
+
+        cout << "exception: " << e << endl;
+        cout << "Mission impossible!\n";
+    }
+
+    return 0;
+}
+
+void fa() {
+    MyClass a("A");
+    fb();
+    cout << "return from fa()\n";
+    return;
+}
+
+void fb() {
+    MyClass b("B");
+    fc();
+    cout << "return from fb()\n";
+    return;
+}
+
+void fc() {
+    MyClass c("C");
+    fd();
+    cout << "return from fc()\n";
+    return;
+}
+
+void fd() {
+    MyClass d("D");
+    throw "in fd(), something weird happened.";
+    cout << "return from fd()\n";
+    return;
+}
+

pool/shard006/C++/0083783_AudioManager.cpp

@@ -0,0 +1,54 @@
+#include "AudioManager.h"
+
+AudioManager& AudioManager::getInstance()
+{
+	static AudioManager s;
+	return s;
+}
+
+void AudioManager::playBackgroundAudio()
+{
+	if (_playing == true)
+		stopBackgroundAudio(); //only one sound thread can be played at the same time
+	background_audioID = AudioEngine::play2d(BACKGROUND_SOUND, true, 1.0f);
+	_playing = true;
+}
+
+void AudioManager::stopBackgroundAudio()
+{
+	AudioEngine::stop(background_audioID);
+	_playing = false;
+}
+
+void AudioManager::pauseBackgroundAudio()
+{
+	AudioEngine::pause(background_audioID);
+	_playing = false;
+}
+
+void AudioManager::resumeBackgroundAudio() 
+{
+	AudioEngine::resume(background_audioID);
+	_playing = true;
+}
+
+void AudioManager::setBackgroundAudioVolume(float value) 
+{
+	AudioEngine::setVolume(background_audioID, value);
+}
+
+float AudioManager::getBackgroundAudioVolume() 
+{
+	return AudioEngine::getVolume(background_audioID);
+}
+
+void AudioManager::endAudio() 
+{
+	_playing = false;
+	AudioEngine::end();
+}
+
+bool AudioManager::isBackgroundMusicPlaying() 
+{
+	return _playing;
+}

pool/shard006/C++/0083789_GrGLShaderStringBuilder.cpp

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrGLShaderStringBuilder.h"
+#include "gl/GrGLGpu.h"
+#include "gl/GrGLSLPrettyPrint.h"
+#include "SkTraceEvent.h"
+
+#define GL_CALL(X) GR_GL_CALL(gpu->glInterface(), X)
+#define GL_CALL_RET(R, X) GR_GL_CALL_RET(gpu->glInterface(), R, X)
+
+// Print the source code for all shaders generated.
+static const bool c_PrintShaders{false};
+
+static void print_shader_source(const char** strings, int* lengths, int count);
+
+GrGLuint GrGLCompileAndAttachShader(const GrGLContext& glCtx,
+                                    GrGLuint programId,
+                                    GrGLenum type,
+                                    const char** strings,
+                                    int* lengths,
+                                    int count,
+                                    GrGpu::Stats* stats) {
+    const GrGLInterface* gli = glCtx.interface();
+
+    GrGLuint shaderId;
+    GR_GL_CALL_RET(gli, shaderId, CreateShader(type));
+    if (0 == shaderId) {
+        return 0;
+    }
+
+#ifdef SK_DEBUG
+    SkString prettySource = GrGLSLPrettyPrint::PrettyPrintGLSL(strings, lengths, count, false);
+    const GrGLchar* sourceStr = prettySource.c_str();
+    GrGLint sourceLength = static_cast<GrGLint>(prettySource.size());
+    GR_GL_CALL(gli, ShaderSource(shaderId, 1, &sourceStr, &sourceLength));
+#else
+    GR_GL_CALL(gli, ShaderSource(shaderId, count, strings, lengths));
+#endif
+
+    // If tracing is enabled in chrome then we pretty print
+    bool traceShader;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), &traceShader);
+    if (traceShader) {
+        SkString shader = GrGLSLPrettyPrint::PrettyPrintGLSL(strings, lengths, count, false);
+        TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "skia_gpu::GLShader",
+                             TRACE_EVENT_SCOPE_THREAD, "shader", TRACE_STR_COPY(shader.c_str()));
+    }
+
+    stats->incShaderCompilations();
+    GR_GL_CALL(gli, CompileShader(shaderId));
+
+    // Calling GetShaderiv in Chromium is quite expensive. Assume success in release builds.
+    bool checkCompiled = kChromium_GrGLDriver != glCtx.driver();
+#ifdef SK_DEBUG
+    checkCompiled = true;
+#endif
+    if (checkCompiled) {
+        GrGLint compiled = GR_GL_INIT_ZERO;
+        GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_COMPILE_STATUS, &compiled));
+
+        if (!compiled) {
+            GrGLint infoLen = GR_GL_INIT_ZERO;
+            GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_INFO_LOG_LENGTH, &infoLen));
+            SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
+            if (infoLen > 0) {
+                // retrieve length even though we don't need it to workaround bug in Chromium cmd
+                // buffer param validation.
+                GrGLsizei length = GR_GL_INIT_ZERO;
+                GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1, &length, (char*)log.get()));
+                print_shader_source(strings, lengths, count);
+                SkDebugf("\n%s", (const char*)log.get());
+            }
+            SkDEBUGFAIL("Shader compilation failed!");
+            GR_GL_CALL(gli, DeleteShader(shaderId));
+            return 0;
+        }
+    }
+
+    if (c_PrintShaders) {
+        print_shader_source(strings, lengths, count);
+    }
+
+    // Attach the shader, but defer deletion until after we have linked the program.
+    // This works around a bug in the Android emulator's GLES2 wrapper which
+    // will immediately delete the shader object and free its memory even though it's
+    // attached to a program, which then causes glLinkProgram to fail.
+    GR_GL_CALL(gli, AttachShader(programId, shaderId));
+
+    return shaderId;
+}
+
+static void print_shader_source(const char** strings, int* lengths, int count) {
+    const SkString& pretty = GrGLSLPrettyPrint::PrettyPrintGLSL(strings, lengths, count, true);
+    SkTArray<SkString> lines;
+    SkStrSplit(pretty.c_str(), "\n", &lines);
+    for (const SkString& line : lines) {
+        // Print the shader one line at the time so it doesn't get truncated by the adb log.
+        SkDebugf("%s\n", line.c_str());
+    }
+}

pool/shard006/C++/0083795_utest_gen_sentence.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include "cppunit/ui/text/TestRunner.h"
+#include "cppunit/TestCaller.h"
+#include "cppunit/extensions/HelperMacros.h"
+#include "gen_sentence.h"
+
+using std::vector;
+using std::string;
+using std::logic_error;
+
+
+
+class GenAuxTest : public CppUnit::TestFixture {
+
+private:
+
+    Grammar *grammar;
+    vector<string> *recipe, *actualize, *location;
+    
+public:
+
+    void setUp() {
+
+	grammar = new Grammar;
+	recipe = new vector<string>;
+	actualize = new vector<string>;
+	location = new vector<string>;
+
+	location->push_back("wherever");
+	location->push_back("it");
+	location->push_back("wants");
+	(*grammar)["<location>"].push_back(*location);
+
+	recipe->push_back("<ending>");
+	
+	actualize->push_back("the");
+	actualize->push_back("dog");
+	actualize->push_back("sits");
+    }
+
+
+    void tearDown() {
+	delete grammar;
+	delete recipe;
+	delete actualize;
+    }
+
+
+    // check behavior for a literal (i.e. not a bracketed rule) word
+    void test_word_literal() {
+
+	Grammar grammar_before = *grammar;
+	vector<string> recipe_before = *recipe;
+	vector<string> actualize_before = *actualize;
+	string word_literal = "yayaya!";
+	
+	gen_aux(*grammar, word_literal, *recipe, *actualize);
+
+	// these should remain unchanged
+	CPPUNIT_ASSERT(*grammar == grammar_before);
+	CPPUNIT_ASSERT(*recipe == recipe_before);
+
+	// should simply append `word_literal' to `*actualize'
+	CPPUNIT_ASSERT(actualize->size() == 4);
+	CPPUNIT_ASSERT((*actualize)[0] == actualize_before[0]);
+	CPPUNIT_ASSERT((*actualize)[1] == actualize_before[1]);
+	CPPUNIT_ASSERT((*actualize)[2] == actualize_before[2]);
+	CPPUNIT_ASSERT((*actualize)[3] == word_literal);
+    }
+
+
+    // check behavior for a rule word
+    void test_word_rule() {
+
+	Grammar grammar_before = *grammar;
+	vector<string> recipe_before = *recipe;
+	vector<string> actualize_before = *actualize;
+	string word_rule = "<location>";
+	
+	gen_aux(*grammar, word_rule, *recipe, *actualize);
+
+	// these should location vector is reverse order
+	CPPUNIT_ASSERT(*grammar == grammar_before);
+	CPPUNIT_ASSERT(*actualize == actualize_before);
+
+	// should append words from (*grammar)["<location>"][0] to *recipe, in
+	// reverse
+	CPPUNIT_ASSERT(recipe->size() == 4);
+	CPPUNIT_ASSERT((*recipe)[0] == recipe_before[0]);
+	CPPUNIT_ASSERT((*recipe)[1] == (*location)[2]);
+	CPPUNIT_ASSERT((*recipe)[2] == (*location)[1]);
+	CPPUNIT_ASSERT((*recipe)[3] == (*location)[0]);
+    }
+
+
+    // check that providing a `word' not defined in `grammer' throws an
+    // exception
+    void test_illegal_word() {
+	CPPUNIT_ASSERT_THROW(gen_aux(*grammar, "<no_rule>", *recipe, *actualize),
+			     logic_error);
+    }
+    
+
+    CPPUNIT_TEST_SUITE(GenAuxTest);
+    CPPUNIT_TEST(test_word_literal);
+    CPPUNIT_TEST(test_word_rule);
+    CPPUNIT_TEST(test_illegal_word);
+    CPPUNIT_TEST_SUITE_END();    
+};
+
+
+
+
+int main() {
+
+    CppUnit::TextUi::TestRunner runner;
+    runner.addTest(GenAuxTest::suite());
+
+    return runner.run() ? 0 : 1;
+}

pool/shard006/C++/0083801_EPattern.cpp

@@ -0,0 +1,249 @@
+/*
+ * EPattern.cpp
+ *
+ *  Created on: 2013-3-25
+ *      Author: cxxjava@163.com
+ */
+
+#include "EPattern.hh"
+#include "EPatternSyntaxException.hh"
+#include "EMatcher.hh"
+
+namespace efc {
+
+EPattern::~EPattern()
+{
+	eso_pcre_free(&_pcre);
+}
+
+EPattern::EPattern(const char* regex, int opetion) THROWS(EPatternSyntaxException)
+{
+	_pattern = regex;
+
+	int v;
+	_pcre = eso_pcre_make(regex, opetion, &v);
+	if (!_pcre) {
+		throw EPatternSyntaxException(__FILE__, __LINE__);
+	}
+}
+
+EString EPattern::pattern()
+{
+	return _pattern;
+}
+
+EString EPattern::toString()
+{
+	return _pattern;
+}
+
+es_pcre_t* EPattern::c_pcre()
+{
+	return _pcre;
+}
+
+EMatcher* EPattern::newMatcher(const char* input)
+{
+	return new EMatcher(this, input);
+}
+
+EArray<EString*> EPattern::split(const char* input, int limit)
+{
+	const char *regex = _pattern.c_str();
+	EArray<EString*> res;
+	EString *s;
+
+	if (!input || !*input) {
+		return res;
+	}
+
+	if (!regex || !*regex) {
+		s = new EString(input);
+		res.add(s);
+		return res;
+	}
+
+	int v, count, length;
+	int ovector[3];
+	char *psrc = (char*)input;
+
+	count = length = 0;
+	while (*psrc && ((limit == 0) || (count < limit))) {
+		v = eso_pcre_exec(_pcre, psrc, -1, 0, 0, ovector, 3);
+		if (v >= 0) {
+			res.add(new EString(psrc, 0, ovector[0]));
+			psrc += ovector[1];
+			count++;
+
+			continue;
+		}
+		else if (v == -1) {
+			res.add(new EString(psrc));
+			break;
+		}
+		else if (v < -1) {
+			throw EPatternSyntaxException(__FILE__, __LINE__);
+		}
+	}
+
+	return res;
+}
+
+EArray<EString*> EPattern::split(const char* regex, const char* input,
+		int limit) THROWS(EPatternSyntaxException)
+{
+	EArray<EString*> res;
+	EString *s;
+
+	if (!input) {
+		return res;
+	}
+	
+	if (!regex || !*regex) {
+		s = new EString(input);
+		res.add(s);
+		return res;
+	}
+
+	//@see: openjdk-8/src/share/classes/java/lang/String.java#L2316
+
+	/* fastpath if the regex is a
+	 (1)one-char String and this character is not one of the
+		RegEx's meta characters ".$|()[{^?*+\\", or
+	 (2)two-char String and the first char is the backslash and
+		the second is not the ascii digit or ascii letter.
+	 */
+	char ch = 0;
+	if (((eso_strlen(regex) == 1 &&
+			eso_strchr(".$|()[{^?*+\\", (ch = regex[0])) == NULL) ||
+			(eso_strlen(regex) == 2 &&
+					regex[0] == '\\' &&
+					(((ch = regex[1])-'0')|('9'-ch)) < 0 &&
+					((ch-'a')|('z'-ch)) < 0 &&
+					((ch-'A')|('Z'-ch)) < 0)))
+	{
+		EString s(input);
+		int off = 0;
+		int next = 0;
+		boolean limited = limit > 0;
+		while ((next = s.indexOf(ch, off)) != -1) {
+			if (!limited || res.size() < limit - 1) {
+				res.add(new EString(s.substring(off, next)));
+				off = next + 1;
+			} else {    // last one
+				//assert (res.size() == limit - 1);
+				res.add(new EString(s.substring(off, s.length())));
+				off = s.length();
+				break;
+			}
+		}
+		// If no match was found, return this
+		if (off == 0) {
+			res.add(new EString(input));
+			return res;
+		}
+
+		// Add remaining segment
+		if (!limited || res.size() < limit)
+			res.add(new EString(s.substring(off, s.length())));
+
+		/* @see:
+		// Construct result
+		int resultSize = list.size();
+		if (limit == 0) {
+			while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
+				resultSize--;
+			}
+		}
+		String[] result = new String[resultSize];
+		return list.subList(0, resultSize).toArray(result);
+		*/
+		int resultSize = res.size();
+		for (int i=resultSize-1; i>=0; i--) {
+			if (res[i]->length() == 0) {
+				res.removeAt(i);
+			} else {
+				break;
+			}
+		}
+
+		return res;
+	}
+
+	//=================================================
+
+	es_pcre_t *pcre;
+	int v, count, length;
+	int ovector[3];
+	char *psrc = (char*)input;
+
+	pcre = eso_pcre_make(regex, 0, &v);
+	if (!pcre) {
+		throw EPatternSyntaxException(__FILE__, __LINE__);
+	}
+
+	count = length = 0;
+	while (*psrc && ((limit == 0) || (count < limit))) {
+		v = eso_pcre_exec(pcre, psrc, -1, 0, 0, ovector, 3);
+		if (v >= 0) {
+			res.add(new EString(psrc, 0, ovector[0]));
+			psrc += ovector[1];
+			count++;
+
+			continue;
+		}
+		else if (v == -1) {
+			res.add(new EString(psrc));
+			break;
+		}
+		else if (v < -1) {
+			eso_pcre_free(&pcre);
+			throw EPatternSyntaxException(__FILE__, __LINE__);
+		}
+	}
+
+	eso_pcre_free(&pcre);
+
+	return res;
+}
+
+boolean EPattern::matches(const char* regex, const char* input) THROWS(EPatternSyntaxException)
+{
+	if ((!input || !*input) && (!regex || !*regex)) {
+		return true;
+	}
+
+	if (!input || !*input) {
+		return false;
+	}
+
+	if (!regex || !*regex) {
+		return false;
+	}
+
+	es_pcre_t *pcre;
+	int v;
+	int ovector[3];
+	boolean ret;
+
+	pcre = eso_pcre_make(regex, 0, &v);
+	if (!pcre) {
+		throw EPatternSyntaxException(__FILE__, __LINE__);
+	}
+
+	v = eso_pcre_exec(pcre, input, -1, 0, 0, ovector, 3);
+	if (v >= 0) {
+		ret = true;
+	} else if (v == -1) {
+		ret = false;
+	} else if (v < -1) {
+		eso_pcre_free(&pcre);
+		throw EPatternSyntaxException(__FILE__, __LINE__);
+	}
+
+	eso_pcre_free(&pcre);
+
+	return ret;
+}
+
+} /* namespace efc */

pool/shard006/C++/0083803_settlement_evaluator.cc

@@ -0,0 +1,89 @@
+/* -*-  mode: c++; indent-tabs-mode: nil -*- */
+
+/*
+  Determining the molar fraction of a gas component within a gas mixture.
+
+  License: BSD
+  Authors:
+*/
+
+#include "settlement_evaluator.hh"
+#include "boost/math/constants/constants.hpp"
+
+namespace Amanzi {
+
+SettlementRateEvaluator :: SettlementRateEvaluator(Teuchos::ParameterList& plist) :
+  SecondaryVariableFieldEvaluator(plist) {
+
+  Key domain_name = "surface";
+  
+  velocity_key_ = plist_.get<std::string>("velocity key",
+                                     Keys::getKey(domain_name,"velocity"));
+
+  sediment_key_ =  plist_.get<std::string>("sediment key",
+                                     Keys::getKey(domain_name,"sediment"));
+
+  tau_d_ = plist_.get<double>("critical shear stress");
+  ws_ = plist_.get<double>("settling velocity");
+  gamma_ = plist_.get<double>("specific weight of water");
+  sediment_density_ = plist_.get<double>("sediment density [kg m^-3]");
+
+  
+  umax_ = plist_.get<double>("max current");
+  xi_ = plist_.get<double>("Chezy parameter");
+
+  double pi = boost::math::constants::pi<double>();
+
+  lambda_ = 8./(3*pi) * (umax_/(xi_*xi_));
+    
+  dependencies_.insert("surface-pressure");
+  dependencies_.insert(sediment_key_);
+    
+}
+
+  
+SettlementRateEvaluator ::SettlementRateEvaluator (const SettlementRateEvaluator & other) :
+  SecondaryVariableFieldEvaluator(other),
+  velocity_key_(other.velocity_key_), sediment_key_(other.sediment_key_) {
+
+  tau_d_ = other.tau_d_;
+  ws_ = other.ws_;
+  gamma_ = other.gamma_;
+  lambda_ = other.lambda_;
+  sediment_density_ = other.sediment_density_;
+} 
+
+
+Teuchos::RCP<FieldEvaluator> SettlementRateEvaluator ::Clone() const {
+  return Teuchos::rcp(new SettlementRateEvaluator (*this));
+}
+
+
+void SettlementRateEvaluator::EvaluateField_(const Teuchos::Ptr<State>& S,
+        const Teuchos::Ptr<CompositeVector>& result) {
+
+  const Epetra_MultiVector& vel = *S->GetFieldData(velocity_key_)->ViewComponent("cell");
+  const Epetra_MultiVector& tcc = *S->GetFieldData(sediment_key_)->ViewComponent("cell");
+  Epetra_MultiVector& result_c = *result->ViewComponent("cell");
+  
+  for (int c=0; c<result_c.MyLength(); c++){
+    double tau_0 = gamma_ * lambda_ * (sqrt(vel[0][c] * vel[0][c] + vel[1][c] * vel[1][c]));
+    
+    if (tau_0 < tau_d_){
+      result_c[0][c] = sediment_density_ * ws_ * std::min(tcc[0][c], 0.5) * (1 - tau_0 / tau_d_);
+    }else{
+      result_c[0][c] = 0.;
+    }
+
+  }
+   
+}
+
+void SettlementRateEvaluator::EvaluateFieldPartialDerivative_ (const Teuchos::Ptr<State>& S,
+                                                            Key wrt_key,
+                                                            const Teuchos::Ptr<CompositeVector>& result) {
+   AMANZI_ASSERT(0); 
+}
+  
+  
+} // namespace

pool/shard006/C++/0083809_hud_ammo.cpp

@@ -0,0 +1,300 @@
+//========= Copyright © 1996-2003, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "hud_macros.h"
+#include "parsemsg.h"
+#include "hud_numericdisplay.h"
+#include "iclientmode.h"
+
+#include <vgui_controls/AnimationController.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays current ammunition level
+//-----------------------------------------------------------------------------
+class CHudAmmo : public CHudNumericDisplay, public CHudElement
+{
+	DECLARE_CLASS_SIMPLE( CHudAmmo, CHudNumericDisplay );
+
+public:
+	CHudAmmo( const char *pElementName );
+	void Init( void );
+	void VidInit( void );
+
+	void SetAmmo(int ammo, bool playAnimation);
+	void SetAmmo2(int ammo2, bool playAnimation);
+		
+protected:
+	virtual void OnThink();
+	
+private:
+	CHandle< C_BaseCombatWeapon > m_hCurrentActiveWeapon;
+	int		m_iAmmo;
+	int		m_iAmmo2;
+};
+
+DECLARE_HUDELEMENT( CHudAmmo );
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudAmmo::CHudAmmo( const char *pElementName ) : BaseClass(NULL, "HudAmmo"), CHudElement( pElementName )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudAmmo::Init( void )
+{
+	m_iAmmo		= -1;
+	m_iAmmo2	= -1;
+
+	SetLabelText(L"AMMO");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudAmmo::VidInit( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called every frame to get ammo info from the weapon
+//-----------------------------------------------------------------------------
+void CHudAmmo::OnThink()
+{
+	C_BaseCombatWeapon *wpn = GetActiveWeapon();
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if (!wpn || !player || !wpn->UsesPrimaryAmmo())
+	{
+		SetPaintEnabled(false);
+		SetPaintBackgroundEnabled(false);
+		return;
+	}
+	else
+	{
+		SetPaintEnabled(true);
+		SetPaintBackgroundEnabled(true);
+	}
+
+	// get the ammo in our clip
+	int ammo1 = wpn->Clip1();
+	int ammo2;
+	if (ammo1 < 0)
+	{
+		// we don't use clip ammo, just use the total ammo count
+		ammo1 = player->GetAmmoCount(wpn->GetPrimaryAmmoType());
+		ammo2 = 0;
+	}
+	else
+	{
+		// we use clip ammo, so the second ammo is the total ammo
+		ammo2 = player->GetAmmoCount(wpn->GetPrimaryAmmoType());
+	}
+
+	if (wpn == m_hCurrentActiveWeapon)
+	{
+		// same weapon, just update counts
+		SetAmmo(ammo1, true);
+		SetAmmo2(ammo2, true);
+	}
+	else
+	{
+		// diferent weapon, change without triggering
+		SetAmmo(ammo1, false);
+		SetAmmo2(ammo2, false);
+
+		// update whether or not we show the total ammo display
+		if (wpn->UsesClipsForAmmo1())
+		{
+			SetShouldDisplaySecondaryValue(true);
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponUsesClips");
+
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponDoesNotUseClips");
+			SetShouldDisplaySecondaryValue(false);
+		}
+
+		if ( GetGameRestored() )
+		{
+			SetGameRestored( false );
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponChangedRestore");
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponChanged");
+		}
+		m_hCurrentActiveWeapon = wpn;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates ammo display
+//-----------------------------------------------------------------------------
+void CHudAmmo::SetAmmo(int ammo, bool playAnimation)
+{
+	if (ammo != m_iAmmo)
+	{
+		if (ammo == 0)
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoEmpty");
+		}
+		else if (ammo < m_iAmmo)
+		{
+			// ammo has decreased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoDecreased");
+		}
+		else
+		{
+			// ammunition has increased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoIncreased");
+		}
+
+		m_iAmmo = ammo;
+	}
+
+	SetDisplayValue(ammo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates 2nd ammo display
+//-----------------------------------------------------------------------------
+void CHudAmmo::SetAmmo2(int ammo2, bool playAnimation)
+{
+	if (ammo2 != m_iAmmo2)
+	{
+		if (ammo2 == 0)
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("Ammo2Empty");
+		}
+		else if (ammo2 < m_iAmmo2)
+		{
+			// ammo has decreased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("Ammo2Decreased");
+		}
+		else
+		{
+			// ammunition has increased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("Ammo2Increased");
+		}
+
+		m_iAmmo2 = ammo2;
+	}
+
+	SetSecondaryValue(ammo2);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays the secondary ammunition level
+//-----------------------------------------------------------------------------
+class CHudSecondaryAmmo : public CHudNumericDisplay, public CHudElement
+{
+	DECLARE_CLASS_SIMPLE( CHudSecondaryAmmo, CHudNumericDisplay );
+
+public:
+	CHudSecondaryAmmo( const char *pElementName ) : BaseClass( NULL, "HudAmmoSecondary" ), CHudElement( pElementName )
+	{
+		m_iAmmo = -1;
+	}
+
+	void Init( void )
+	{
+	}
+
+	void VidInit( void )
+	{
+	}
+
+	void SetAmmo( int ammo )
+	{
+		if (ammo != m_iAmmo)
+		{
+			if (ammo == 0)
+			{
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoSecondaryEmpty");
+			}
+			else if (ammo < m_iAmmo)
+			{
+				// ammo has decreased
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoSecondaryDecreased");
+			}
+			else
+			{
+				// ammunition has increased
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("AmmoSecondaryIncreased");
+			}
+
+			m_iAmmo = ammo;
+		}
+		SetDisplayValue( ammo );
+	}
+
+protected:
+	virtual void OnThink( void )
+	{
+		// set whether or not the panel draws based on if we have a weapon that supports secondary ammo
+		C_BaseCombatWeapon *wpn = GetActiveWeapon();
+		C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+		if (!wpn || !player)
+		{
+			m_hCurrentActiveWeapon = NULL;
+			SetPaintEnabled(false);
+			SetPaintBackgroundEnabled(false);
+			return;
+		}
+		else
+		{
+			SetPaintEnabled(true);
+			SetPaintBackgroundEnabled(true);
+		}
+
+		if (wpn->UsesSecondaryAmmo())
+		{
+			SetAmmo(player->GetAmmoCount(wpn->GetSecondaryAmmoType()));
+		}
+
+		if ( m_hCurrentActiveWeapon != wpn )
+		{
+			bool restored = false;
+			if ( GetGameRestored() )
+			{
+				SetGameRestored( false );
+				restored = true;
+			}
+
+			if ( wpn->UsesSecondaryAmmo() )
+			{
+				// we've changed to a weapon that uses secondary ammo
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
+					restored ?
+					"WeaponUsesSecondaryAmmoRestore" : 
+					"WeaponUsesSecondaryAmmo");
+			}
+			else 
+			{
+				// we've changed away from a weapon that uses secondary ammo
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
+					restored ?
+					"WeaponDoesNotUseSecondaryAmmoRestore" :
+					"WeaponDoesNotUseSecondaryAmmo" );
+			}
+			m_hCurrentActiveWeapon = wpn;
+		}
+	}
+	
+private:
+	CHandle< C_BaseCombatWeapon > m_hCurrentActiveWeapon;
+	int		m_iAmmo;
+};
+
+DECLARE_HUDELEMENT( CHudSecondaryAmmo );
+

pool/shard006/C++/0083818_DecoderPD.cpp

@@ -0,0 +1,140 @@
+/*
+ *  DecoderPD.cpp
+ *  zxing
+ *
+ *  Created by Hartmut Neubauer (hfn), 2012-05-25 (translated from Java source)
+ *  Copyright 2010,2012 ZXing authors 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.
+ * 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.
+ *
+ * 2012-06-27 hfn: PDF417 Reed-Solomon error correction, using following Java
+ * source code:
+ * http://code.google.com/p/zxing/issues/attachmentText?id=817&aid=8170033000&name=pdf417-java-reed-solomon-error-correction-2.patch&token=0819f5d7446ae2814fd91385eeec6a11
+ */
+
+#include <zxing/pdf417/decoder/Decoder.h>
+#include <zxing/pdf417/decoder/BitMatrixParser.h>
+#include <zxing/pdf417/decoder/DecodedBitStreamParser.h>
+#include <zxing/pdf417/decoder/PDF417RSDecoder.h>
+#include <zxing/ReaderException.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+
+
+namespace zxing {
+namespace pdf417 {
+
+using namespace std;
+
+Decoder::Decoder() 
+{
+}
+
+const int Decoder::MAX_ERRORS = 3; /* 3; / 8? */
+const int Decoder::MAX_EC_CODEWORDS = 512;
+
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
+    // Construct a parser to read the data codewords and error-correction level
+    BitMatrixParser parser(bits);
+	size_t cwsize;
+    ArrayRef<int> codewords(parser.readCodewords());
+	cwsize = codewords.size();
+    if (cwsize == 0) {
+      throw FormatException("PDF:Decoder:decode: cannot read codewords");
+    }
+
+    int ecLevel = parser.getECLevel();
+    int numECCodewords = 1 << (ecLevel + 1);
+    ArrayRef<int> erasures = parser.getErasures();
+
+    correctErrors(codewords, erasures, numECCodewords);
+    verifyCodewordCount(codewords, numECCodewords);
+
+    // Decode the codewords
+    return DecodedBitStreamParser::decode(codewords);
+}
+
+  /**
+   * Verify that all is OK with the codeword array.
+   *
+   * @param codewords
+   * @return an index to the first data codeword.
+   * @throws FormatException
+   */
+void Decoder::verifyCodewordCount(ArrayRef<int> codewords, int numECCodewords)
+{
+	int cwsize = codewords.size();
+	if (cwsize < 4) {
+	  // Codeword array size should be at least 4 allowing for
+	  // Count CW, At least one Data CW, Error Correction CW, Error Correction CW
+	  throw FormatException("PDF:Decoder:verifyCodewordCount: codeword array too small!");
+	}
+	// The first codeword, the Symbol Length Descriptor, shall always encode the total number of data
+	// codewords in the symbol, including the Symbol Length Descriptor itself, data codewords and pad
+	// codewords, but excluding the number of error correction codewords.
+	int numberOfCodewords = codewords[0];
+	if (numberOfCodewords > cwsize) {
+	  throw FormatException("PDF:Decoder:verifyCodewordCount: bad codeword number descriptor!");
+	}
+	if (numberOfCodewords == 0) {
+	  // Reset to the length of the array - 8 (Allow for at least level 3 Error Correction (8 Error Codewords)
+	  if (numECCodewords < cwsize) {
+		codewords[0] = cwsize - numECCodewords;
+	  } else {
+	    throw FormatException("PDF:Decoder:verifyCodewordCount: bad error correction cw number!");
+	  }
+	}
+}
+
+int Decoder::correctErrors(ArrayRef<int> codewords, 
+  ArrayRef<int> erasures, int numECCodewords) {
+#if (defined _WIN32 && defined(DEBUG))
+	  {
+		  WCHAR sz[256];
+		  wsprintf(sz,L"Decoder::correctErrors: erasures.size=%d, numECCodewords=%d\n",erasures.size(),numECCodewords);
+		  OutputDebugString(sz);
+	  }
+#endif
+    int numErasures = erasures.size();
+    if (numErasures > numECCodewords - 3
+		|| numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
+      // Too many errors or EC Codewords is corrupted
+      throw FormatException("PDF:Decoder:correctErrors: Too many errors or EC Codewords corrupted");
+    }
+    // Try to correct the errors
+    // Use class PDF417RSDecoder for Reed-Solomon error correction
+	Ref<PDF417RSDecoder> rsDecoder(new PDF417RSDecoder);
+	int synd_len = codewords.size() - codewords[0];
+	int numCorrections = rsDecoder->correctErrors(codewords,
+		erasures, /* hint: "erasures" are ignored when num_eras=0! */
+		0, // erasures.size(),
+		codewords.size(),synd_len);
+	if(numCorrections < 0)
+	{
+      // Still too many errors
+      throw FormatException("PDF:Decoder:correctErrors: Error correction not possible!");
+    }
+
+	//* 2012-06-27 HFN if, despite of error correction, there are still codewords with invalid
+	//* value, throw an exception here:
+	int i;
+	for(i=0;i<(int)codewords.size();i++) {
+		if(codewords[i]<0) {
+			throw FormatException("PDF:Decoder:correctErrors: Error correction did not succeed!");
+		}
+	}
+
+	return numCorrections;
+}
+
+} /* namespace pdf417 */
+} /* namespace zxing */

pool/shard006/C++/0083820_test_polyhedron_io.cpp

@@ -0,0 +1,138 @@
+// ============================================================================
+//
+// Copyright (c) 1997 The CGAL Consortium
+//
+// This software and related documentation is part of an INTERNAL release
+// of the Computational Geometry Algorithms Library (CGAL). It is not
+// intended for general use.
+//
+// ----------------------------------------------------------------------------
+//
+// release       : $CGAL_Revision: $
+// release_date  : $CGAL_Date: $
+//
+// file          : test_polyhedron_io.C
+// chapter       : $CGAL_Chapter: Support Library ... $
+// package       : $CGAL_Package: Polyhedron_IO 2.11 (04 Feb 2000) $
+// source        : polyhedron_io.fw
+// revision      : $Id$
+// revision_date : $Date$
+// author(s)     : Lutz Kettner  <kettner@inf.ethz.ch>
+//
+// coordinator   : Herve Bronnimann  <Herve.Bronnimann@sophia.inria.fr>
+//
+// Polyhedral Surface File IO: Scanner and Writer
+// ============================================================================
+
+
+#include <CGAL/Cartesian.h>
+#include <CGAL/Polyhedron_3.h>
+
+// This is the test file for the new design. Skip new design test for 
+// disabled compilers.
+#ifndef CGAL_USE_POLYHEDRON_DESIGN_ONE
+
+#include <CGAL/IO/Polyhedron_iostream.h>
+#include <CGAL/IO/print_OFF.h>
+#include <CGAL/IO/print_wavefront.h>
+#include <CGAL/IO/print_inventor.h>
+#include <CGAL/IO/print_VRML_1.h>
+#include <CGAL/IO/print_VRML_2.h>
+
+#include <cstddef>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <cstring>
+#include <cassert>
+
+using namespace CGAL;
+
+const char* triangle = "OFF\n"
+                       "3 1 0\n"
+                       "0 0 0\n"
+                       "1 0 0\n"
+                       "0 1 0\n"
+                       "3  0 1 2\n";
+const char* tetra =    "OFF\n"
+                       "4 4 0\n"
+                       "0 0 0.707107\n"
+                       "1 1 0.707107\n"
+                       "0 1 0\n"
+                       "1 0 0\n"
+                       "3  1 3 0\n"
+                       "3  2 1 0\n"
+                       "3  3 2 0\n"
+                       "3  2 3 1\n";
+
+
+void test_file_IO_OFF() {
+    typedef Cartesian<double>     Kernel;
+    typedef Polyhedron_3<Kernel>  Polyhedron;
+    {
+        Polyhedron P;
+        std::istringstream in( triangle);
+        in >> P;    /* 'in' is the stream where the object is read from. */
+        assert(! in.fail());
+        assert( P.is_triangle( P.halfedges_begin()));
+        std::stringstream stream;
+        stream << P << '\0';
+        P = Polyhedron();
+        scan_OFF( stream, P, true);
+        assert( ! ! stream); // ! ! to fool VC7 CL1310
+        assert( P.is_triangle( P.halfedges_begin()));
+
+        std::stringstream stream_new;
+        print_polyhedron_OFF( stream_new, P, true);
+        stream_new << '\0';
+        P = Polyhedron();
+        stream_new >> P;
+        assert( ! ! stream_new); // ! ! to fool VC7 CL1310
+        assert( P.is_triangle( P.halfedges_begin()));
+        {
+            std::ofstream out2( "triangle_binary.off");
+            print_polyhedron_OFF( out2, P, true);
+        }
+        std::ifstream filein( "triangle_binary.off");
+        P = Polyhedron();
+        filein >> P;
+        assert(! filein.fail());
+        assert( P.is_triangle( P.halfedges_begin()));
+    }{
+        Polyhedron P;
+        std::istringstream in( tetra);
+        in >> P;    /* 'in' is the stream where the object is read from. */
+        assert( P.is_tetrahedron( P.halfedges_begin()));
+        std::stringstream stream;
+        stream << P << '\0';
+        P = Polyhedron();
+        stream >> P;
+        assert( P.is_tetrahedron( P.halfedges_begin()));
+        {
+            std::ofstream out2( "tetra_binary.off");
+            print_polyhedron_OFF( out2, P, true);
+        }
+        std::ifstream filein( "tetra_binary.off");
+        P = Polyhedron();
+        filein >> P;
+        assert( P.is_tetrahedron( P.halfedges_begin()));
+    }
+}
+void test_file_IO_wavefront() {}
+void test_file_IO_inventor() {}
+void test_file_IO_VRML_2() {}
+
+#endif // CGAL_USE_POLYHEDRON_DESIGN_ONE //
+
+int main(){
+// This is the test file for the new design. Skip new design test for 
+// disabled compilers.
+#ifndef CGAL_USE_POLYHEDRON_DESIGN_ONE
+    test_file_IO_OFF();
+    test_file_IO_wavefront();
+    test_file_IO_inventor();
+    test_file_IO_VRML_2();
+#endif // CGAL_USE_POLYHEDRON_DESIGN_ONE //
+    return 0;
+}
+// EOF //

pool/shard006/C++/0083822_PlatformCanvas.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2011 Google Inc. 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 APPLE AND ITS 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 APPLE OR ITS 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 "config.h"
+
+#include "PlatformCanvas.h"
+
+#include "GraphicsContext.h"
+
+#include "NativeImageSkia.h"
+#include "PlatformContextSkia.h"
+#include "SkColorPriv.h"
+#include "skia/ext/platform_canvas.h"
+
+namespace WebCore {
+
+PlatformCanvas::PlatformCanvas()
+    : m_opaque(false)
+{
+}
+
+PlatformCanvas::~PlatformCanvas()
+{
+}
+
+void PlatformCanvas::resize(const IntSize& size)
+{
+    if (m_size == size)
+        return;
+    m_size = size;
+    createBackingCanvas();
+}
+
+void PlatformCanvas::setOpaque(bool opaque)
+{
+    if (opaque == m_opaque)
+        return;
+
+    m_opaque = opaque;
+    createBackingCanvas();
+}
+
+void PlatformCanvas::createBackingCanvas()
+{
+    if (m_size.isEmpty())
+        return;
+
+    m_skiaCanvas = adoptPtr(skia::CreateBitmapCanvas(m_size.width(), m_size.height(), m_opaque));
+}
+
+PlatformCanvas::AutoLocker::AutoLocker(PlatformCanvas* canvas)
+    : m_canvas(canvas)
+{
+    if (m_canvas->m_skiaCanvas) {
+        m_bitmap = &m_canvas->m_skiaCanvas->getDevice()->accessBitmap(false);
+        m_bitmap->lockPixels();
+    } else
+        m_bitmap = 0;
+}
+
+PlatformCanvas::AutoLocker::~AutoLocker()
+{
+    if (m_bitmap)
+        m_bitmap->unlockPixels();
+}
+
+const uint8_t* PlatformCanvas::AutoLocker::pixels() const
+{
+    if (m_bitmap && m_bitmap->config() == SkBitmap::kARGB_8888_Config)
+        return static_cast<const uint8_t*>(m_bitmap->getPixels());
+    return 0;
+}
+
+PlatformCanvas::Painter::Painter(PlatformCanvas* canvas, PlatformCanvas::Painter::TextOption option)
+{
+    m_skiaContext = adoptPtr(new PlatformContextSkia(canvas->m_skiaCanvas.get()));
+
+    m_skiaContext->setDrawingToImageBuffer(option == GrayscaleText);
+
+    m_context = adoptPtr(new GraphicsContext(reinterpret_cast<PlatformGraphicsContext*>(m_skiaContext.get())));
+    context()->save();
+}
+
+PlatformCanvas::Painter::~Painter()
+{
+    context()->restore();
+}
+
+} // namespace WebCore

pool/shard006/C++/0083825_MapWindowTraffic.cpp

@@ -0,0 +1,134 @@
+/*
+Copyright_License {
+
+  XCSoar Glide Computer - http://www.xcsoar.org/
+  Copyright (C) 2000-2012 The XCSoar Project
+  A detailed list of copyright holders can be found in the file "AUTHORS".
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+}
+*/
+
+#include "MapWindow.hpp"
+#include "Math/Screen.hpp"
+#include "Math/Earth.hpp"
+#include "Screen/Icon.hpp"
+#include "Screen/Fonts.hpp"
+#include "Screen/Layout.hpp"
+#include "Screen/TextInBox.hpp"
+#include "Util/StringUtil.hpp"
+#include "GlideSolvers/GlidePolar.hpp"
+#include "Formatter/UserUnits.hpp"
+#include "Look/TrafficLook.hpp"
+#include "Renderer/TrafficRenderer.hpp"
+
+#include <stdio.h>
+
+/**
+ * Draws the FLARM traffic icons onto the given canvas
+ * @param canvas Canvas for drawing
+ */
+void
+MapWindow::DrawFLARMTraffic(Canvas &canvas,
+                            const RasterPoint aircraft_pos) const
+{
+  // Return if FLARM icons on moving map are disabled
+  if (!GetMapSettings().show_flarm_on_map)
+    return;
+
+  // Return if FLARM data is not available
+  const FlarmState &flarm = Basic().flarm;
+  if (!flarm.available)
+    return;
+
+  const WindowProjection &projection = render_projection;
+
+  // if zoomed in too far out, dont draw traffic since it will be too close to
+  // the glider and so will be meaningless (serves only to clutter, cant help
+  // the pilot)
+  if (projection.GetMapScale() > fixed_int_constant(7300))
+    return;
+
+  // Circle through the FLARM targets
+  for (auto it = flarm.traffic.begin(), end = flarm.traffic.end();
+      it != end; ++it) {
+    const FlarmTraffic &traffic = *it;
+
+    if (!traffic.location_available)
+      continue;
+
+    // Save the location of the FLARM target
+    GeoPoint target_loc = traffic.location;
+
+    // Points for the screen coordinates for the icon, name and average climb
+    RasterPoint sc, sc_name, sc_av;
+
+    // If FLARM target not on the screen, move to the next one
+    if (!projection.GeoToScreenIfVisible(target_loc, sc))
+      continue;
+
+    // Draw the name 16 points below the icon
+    sc_name = sc;
+    sc_name.y -= Layout::Scale(20);
+
+    // Draw the average climb value above the icon
+    sc_av = sc;
+    sc_av.y += Layout::Scale(5);
+
+    TextInBoxMode mode;
+    mode.mode = RM_OUTLINED;
+
+    // JMW TODO enhancement: decluttering of FLARM altitudes (sort by max lift)
+
+    int dx = sc_av.x - aircraft_pos.x;
+    int dy = sc_av.y - aircraft_pos.y;
+
+    // only draw labels if not close to aircraft
+    if (dx * dx + dy * dy > Layout::Scale(30 * 30)) {
+      // If FLARM callsign/name available draw it to the canvas
+      if (traffic.HasName() && !StringIsEmpty(traffic.name))
+        TextInBox(canvas, traffic.name, sc_name.x, sc_name.y,
+                  mode, GetClientRect());
+
+      if (traffic.climb_rate_avg30s >= fixed(0.1)) {
+        // If average climb data available draw it to the canvas
+        TCHAR label_avg[100];
+        FormatUserVerticalSpeed(traffic.climb_rate_avg30s,
+                                       label_avg, false);
+        TextInBox(canvas, label_avg, sc_av.x, sc_av.y, mode, GetClientRect());
+      }
+    }
+
+    TrafficRenderer::Draw(canvas, traffic_look, traffic,
+                          traffic.track - projection.GetScreenAngle(), sc);
+  }
+}
+
+/**
+ * Draws the teammate icon to the given canvas
+ * @param canvas Canvas for drawing
+ */
+void
+MapWindow::DrawTeammate(Canvas &canvas) const
+{
+  const TeamInfo &teamcode_info = Calculated();
+
+  if (teamcode_info.teammate_available) {
+    RasterPoint sc;
+    if (render_projection.GeoToScreenIfVisible(teamcode_info.teammate_location,
+                                                 sc))
+      traffic_look.teammate_icon.Draw(canvas, sc);
+  }
+}

pool/shard006/C++/0083827_FontGenerator.cpp

@@ -0,0 +1,112 @@
+//#define _DEBUG_GENERATE_TGA_FILES_
+
+#include "FontGenerator.h"
+#include <pragma/image/Fonts/Font.h>
+#include <pragma/types.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#ifdef _DEBUG_GENERATE_TGA_FILES_
+#	include <pragma/image/functions.h>
+#endif
+
+static bool			sFreeType_Initialized = false;
+static FT_Library	sLibrary; 
+
+namespace pragma
+{
+	
+	static void ExtractGlyph(Font::Glyph& aGlyph, FT_Face aFace, uint32 aCharCode)
+	{
+		FT_UInt lGlyphIndex = FT_Get_Char_Index( aFace, aCharCode );
+		FT_Load_Glyph(aFace, lGlyphIndex, 0);
+		FT_Render_Glyph(aFace->glyph, FT_RENDER_MODE_NORMAL);
+
+		aGlyph.mCode	 = aCharCode;
+		aGlyph.mBitmap	 = aFace->glyph->bitmap.buffer;
+		aGlyph.mWidth	 = aFace->glyph->bitmap.width;
+		aGlyph.mHeight	 = aFace->glyph->bitmap.rows;
+		aGlyph.mStartX	 = aFace->glyph->bitmap_left;
+		aGlyph.mStartY	 = aFace->glyph->bitmap_top;
+		aGlyph.mAdvanceX = aFace->glyph->advance.x;
+
+#ifdef _DEBUG_GENERATE_TGA_FILES_
+		char lNane[10];
+		sprintf(lNane, "glyph%d.tga", aCharCode);
+		pragma::ExportToTGA( aGlyph.mBitmap
+							, aGlyph.mWidth
+							, aGlyph.mHeight
+							, lNane );
+#endif
+	}
+
+	/**
+	 *	CreateFont_FreeType
+	 */
+	void CreateFont_FreeType( const char* aFontFile, size_t aSize, uint32* aRanges, Font& aFont )
+	{
+		int error;
+		// Initialize FreeType library, if needed
+		if(!sFreeType_Initialized)
+		{
+			error = FT_Init_FreeType( &sLibrary );
+			if(error)
+			{
+				printf( "CreateFont_FreeType: Error initializing FreeType library\n");
+				return;
+			}
+			sFreeType_Initialized = true;			
+		}
+
+		// Initialize font face
+		FT_Face lFace;
+		error = FT_New_Face( sLibrary, aFontFile, 0, &lFace );
+		
+		if(error)
+		{
+			printf( "Error opening font\n");
+			return;
+		}
+
+		// Set Font size
+		FT_Set_Char_Size  ( lFace, 0, aSize << 6, 300, 300 );
+		FT_Set_Pixel_Sizes( lFace, 0, aSize );
+		
+		aFont.Init(aSize);
+		
+		if(aRanges == 0)
+		{	// Extract all glyphs
+			FT_UInt lIndex;
+			FT_ULong lCharCode = FT_Get_First_Char(lFace, &lIndex);
+			for(size_t i = 0; i < lFace->num_glyphs; ++i)
+			{
+				Font::Glyph lGlyph;
+				ExtractGlyph(lGlyph, lFace, lCharCode);
+				aFont.AddGlyph(lGlyph);
+				lCharCode = FT_Get_Next_Char(lFace, lCharCode, &lIndex);
+			}
+		}
+		else
+		{	// Extract only a range of glyphs
+			while(aRanges[0] <= aRanges[1])
+			{
+				for(uint32 i = aRanges[0]; i <= aRanges[1]; ++i)
+				{
+					Font::Glyph lGlyph;
+					ExtractGlyph(lGlyph, lFace, i);
+					aFont.AddGlyph(lGlyph);
+				}
+				aRanges+=2;
+			}
+		}
+
+	}
+
+	/**
+	 *	CreateFont_FreeType
+	 */
+	void CreateFont_FreeType( const char* aFontFile, size_t aSize, Font& aFont )
+	{
+		CreateFont_FreeType( aFontFile, aSize, 0, aFont);
+	}
+}

pool/shard006/C++/0083833_shape.cc

@@ -0,0 +1,177 @@
+#include "shape.h"
+
+#include "Contours.h"
+#include "../common/Point.h"
+
+namespace ncv {
+
+  namespace imgproc {
+
+    void ShapeInit(Local<Object> &target) {
+      // connected components algorithms types
+      DEFINE_CONST_ENUM(CCL_WU);
+      DEFINE_CONST_ENUM(CCL_DEFAULT);
+      DEFINE_CONST_ENUM(CCL_GRANA);
+
+      // connected components types
+      DEFINE_CONST_ENUM(CC_STAT_LEFT);
+      DEFINE_CONST_ENUM(CC_STAT_TOP);
+      DEFINE_CONST_ENUM(CC_STAT_WIDTH);
+      DEFINE_CONST_ENUM(CC_STAT_HEIGHT);
+      DEFINE_CONST_ENUM(CC_STAT_AREA);
+      DEFINE_CONST_ENUM(CC_STAT_MAX);
+
+      // contour approximation modes
+      DEFINE_CONST_ENUM(CHAIN_APPROX_NONE);
+      DEFINE_CONST_ENUM(CHAIN_APPROX_SIMPLE);
+      DEFINE_CONST_ENUM(CHAIN_APPROX_TC89_L1);
+      DEFINE_CONST_ENUM(CHAIN_APPROX_TC89_KCOS);
+
+      // rectangles intersect types
+      DEFINE_CONST_ENUM(INTERSECT_NONE);
+      DEFINE_CONST_ENUM(INTERSECT_PARTIAL);
+      DEFINE_CONST_ENUM(INTERSECT_FULL);
+
+      // retrieval modes
+      DEFINE_CONST_ENUM(RETR_EXTERNAL);
+      DEFINE_CONST_ENUM(RETR_LIST);
+      DEFINE_CONST_ENUM(RETR_CCOMP);
+      DEFINE_CONST_ENUM(RETR_TREE);
+      DEFINE_CONST_ENUM(RETR_FLOODFILL);
+
+      // shape match modes
+      DEFINE_CONST_ENUM(CONTOURS_MATCH_I1);
+      DEFINE_CONST_ENUM(CONTOURS_MATCH_I2);
+      DEFINE_CONST_ENUM(CONTOURS_MATCH_I3);
+
+      Nan::SetMethod(target, "approxPolyDP", ApproxPolyDP);
+      Nan::SetMethod(target, "arcLength", ArcLength);
+      Nan::SetMethod(target, "boundingRect", BoundingRect);
+      Nan::SetMethod(target, "boxPoints", BoxPoints);
+      Nan::SetMethod(target, "connectedComponents", ConnectedComponents);
+      Nan::SetMethod(target, "connectedComponentsWithStats", ConnectedComponentsWithStats);
+      Nan::SetMethod(target, "contourArea", ContourArea);
+      Nan::SetMethod(target, "convexHull", ConvexHull);
+      Nan::SetMethod(target, "convexityDefects", ConvexityDefects);
+      Nan::SetMethod(target, "findContours", FindContours);
+      Nan::SetMethod(target, "fitEllipse", FitEllipse);
+      Nan::SetMethod(target, "fitLine", FitLine);
+      Nan::SetMethod(target, "huMoments", HuMoments);
+      Nan::SetMethod(target, "intersectConvexConvex", IntersectConvexConvex);
+      Nan::SetMethod(target, "isContourConvex", IsContourConvex);
+      Nan::SetMethod(target, "matchShapes", MatchShapes);
+      Nan::SetMethod(target, "minAreaRect", MinAreaRect);
+      Nan::SetMethod(target, "minEnclosingCircle", MinEnclosingCircle);
+      Nan::SetMethod(target, "minEnclosingTriangle", MinEnclosingTriangle);
+      Nan::SetMethod(target, "moments", Moments);
+      Nan::SetMethod(target, "pointPolygonTest", PointPolygonTest);
+      Nan::SetMethod(target, "rotatedRectangleIntersection", RotatedRectangleIntersection);
+    }
+
+    NAN_METHOD(ApproxPolyDP) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ArcLength) {
+      NotImplemented
+    }
+
+    NAN_METHOD(BoundingRect) {
+      NotImplemented
+    }
+
+    NAN_METHOD(BoxPoints) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ConnectedComponents) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ConnectedComponentsWithStats) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ContourArea) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ConvexHull) {
+      NotImplemented
+    }
+
+    NAN_METHOD(ConvexityDefects) {
+      NotImplemented
+    }
+
+    NAN_METHOD(FindContours) {
+      FUNCTION_REQUIRE_ARGUMENTS_RANGE(3, 4);
+      Nan::HandleScope scope;
+      ASSERT_INPUTOUTPUTARRAY_FROM_ARGS(image, 0);
+      ASSERT_INT_FROM_ARGS(mode, 1);
+      ASSERT_INT_FROM_ARGS(method, 2);
+      DEFAULT_POINT_FROM_ARGS(offset, 2, cv::Point());
+
+      Local<Object> out = Contours::NewInstance();
+      Contours* contours = UNWRAP_OBJECT(Contours, out);
+      TRY_CATCH_THROW_OPENCV(cv::findContours(image, contours->contours, contours->hierarchy, mode, method, offset));
+
+      info.GetReturnValue().Set(out);
+    }
+
+    NAN_METHOD(FitEllipse) {
+      NotImplemented
+    }
+
+    NAN_METHOD(FitLine) {
+      NotImplemented
+    }
+
+    NAN_METHOD(HuMoments) {
+      NotImplemented
+    }
+
+    NAN_METHOD(IntersectConvexConvex) {
+      NotImplemented
+    }
+
+    NAN_METHOD(IsContourConvex) {
+      NotImplemented
+    }
+
+    NAN_METHOD(MatchShapes) {
+      FUNCTION_REQUIRE_ARGUMENTS(4);
+      ASSERT_INPUTARRAY_FROM_ARGS(contour1, 0);
+      ASSERT_INPUTARRAY_FROM_ARGS(contour2, 1);
+      ASSERT_INT_FROM_ARGS(method, 2);
+      ASSERT_DOUBLE_FROM_ARGS(parameter, 3);
+      TRY_CATCH_THROW_OPENCV(info.GetReturnValue().Set(Nan::New<Number>(cv::matchShapes(contour1, contour2, method, parameter))));
+    }
+
+    NAN_METHOD(MinAreaRect) {
+      NotImplemented
+    }
+
+    NAN_METHOD(MinEnclosingCircle) {
+      NotImplemented
+    }
+
+    NAN_METHOD(MinEnclosingTriangle) {
+      NotImplemented
+    }
+
+    NAN_METHOD(Moments) {
+      NotImplemented
+    }
+
+    NAN_METHOD(PointPolygonTest) {
+      NotImplemented
+    }
+
+    NAN_METHOD(RotatedRectangleIntersection) {
+      NotImplemented
+    }
+
+  }
+
+}

pool/shard006/C++/0083835_mat_mul.cpp

@@ -0,0 +1,104 @@
+/* $Id$ */
+/* --------------------------------------------------------------------------
+CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
+
+CppAD is distributed under multiple licenses. This distribution is under
+the terms of the 
+                    Eclipse Public License Version 1.0.
+
+A copy of this license is included in the COPYING file of this distribution.
+Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
+-------------------------------------------------------------------------- */
+/*
+$begin fadbad_mat_mul.cpp$$
+$spell
+	badiff
+	sq
+	retape
+	typedef
+	diff
+	Fadbad
+	Adolc
+	cppad.hpp
+	bool
+	mul
+	dz
+	CppAD
+$$
+
+$section Fadbad Speed: Matrix Multiplication$$
+
+$index link_mat_mul, fadbad$$
+$index fadbad, link_mat_mul$$
+$index speed, fadbad$$
+$index fadbad, speed$$
+$index matrix, speed fadbad$$
+$index multiply, speed fadbad$$
+
+$head Specifications$$
+See $cref link_mat_mul$$.
+
+$head Implementation$$
+
+$codep */
+# include <FADBAD++/badiff.h>
+# include <cppad/speed/mat_sum_sq.hpp>
+# include <cppad/speed/uniform_01.hpp>
+# include <cppad/vector.hpp>
+bool link_mat_mul(
+	size_t                           size     , 
+	size_t                           repeat   , 
+	CppAD::vector<double>&           x        ,
+	CppAD::vector<double>&           z        ,
+	CppAD::vector<double>&           dz       )
+{
+	// speed test global option values
+	extern bool global_retape, global_atomic, global_optimize;
+	if( ! global_retape || global_atomic || global_optimize )
+		return false;
+
+	// The correctness check for this test is failing, so abort (for now).
+	return false;
+
+	// -----------------------------------------------------
+	// setup
+
+	// object for computing determinant
+	typedef fadbad::B<double>       ADScalar; 
+	typedef CppAD::vector<ADScalar> ADVector; 
+
+	size_t j;                // temporary index
+	size_t m = 1;            // number of dependent variables
+	size_t n = size * size;  // number of independent variables
+	ADVector   X(n);         // AD domain space vector
+	ADVector   Y(n);         // Store product matrix
+	ADVector   Z(m);         // AD range space vector
+	
+	// ------------------------------------------------------
+	while(repeat--)
+	{	// get the next matrix
+		CppAD::uniform_01(n, x);
+
+		// set independent variable values
+		for(j = 0; j < n; j++)
+			X[j] = x[j];
+
+		// do the computation
+		mat_sum_sq(size, X, Y, Z);
+
+		// create function object f : X -> Z
+		Z[0].diff(0, m);  // index 0 of m dependent variables
+
+		// evaluate and return gradient using reverse mode
+		for(j = 0; j < n; j++)
+			dz[j] = X[j].d(0); // partial Z[0] w.r.t X[j]
+	}
+	// return function value
+	z[0] = Z[0].x();
+
+	// ---------------------------------------------------------
+	return true;
+}
+/* $$
+$end
+*/

pool/shard006/C++/0083836_core_types.cpp

@@ -0,0 +1,73 @@
+#include "core_types.h"
+#include "error_macros.h"
+
+#include <QVariant>
+#include <QDebug>
+
+bool Interval::isInTimePeriod(qint64 start, qint64 end) const
+{
+    return ((start >= startTime && end <= endTime)
+             ||
+            (start >= startTime && end >= startTime && endTime >= start)
+             ||
+            (start <= startTime && end >= startTime));
+}
+
+void Activity::updateStartAndEndTime()
+{
+    qint64 min = INT64_MAX, max = INT64_MIN;
+    if (intervals.count() == 0) return;
+
+    for (const Interval & interval : intervals)
+    {
+        if (interval.startTime < min) min = interval.startTime;
+        if (interval.endTime   > max) max = interval.endTime;
+    }
+
+    startTime = min;
+    endTime   = max;
+}
+
+bool Activity::belongsToTimePeriod(qint64 startTime, qint64 endTime) const
+{
+    if (intervals.count() == 0)
+    {
+        return (startTime >= this->startTime && endTime <= this->endTime)
+                ||
+               (startTime >= this->startTime && endTime >= this->startTime && this->endTime >= startTime)
+                ||
+               (startTime <= this->startTime && endTime >= this->startTime);
+    }
+
+    for (const Interval & interval : intervals)
+    {
+        /* this one is better i guess
+        (startTime >= interval.startTime && endTime >= interval.startTime && interval.endTime >= startTime)
+        ||
+        (startTime <= interval.startTime && endTime >= interval.startTime);
+        */
+       if ((startTime >= interval.startTime && endTime <= interval.endTime)
+            ||
+           (startTime >= interval.startTime && endTime >= interval.startTime && interval.endTime >= startTime)
+            ||
+           (startTime <= interval.startTime && endTime >= interval.startTime))
+       {
+           return true;
+       }
+    }
+
+    return false;
+}
+
+
+qint64 Activity::duration() const
+{
+    qint64 duration = 0;
+
+    for (const Interval & interval : intervals)
+    {
+        duration += interval.duration();
+    }
+
+    return duration;
+}

pool/shard006/C++/0083838_QQSound.cpp

@@ -0,0 +1,22 @@
+#include "QQSound.h"
+
+#include <QtCore/QDir>
+#include <QtCore/QFileInfo>
+
+
+QQSound::QQSound(const QString & filename,
+                 QObject *parent)
+    : QSound(filename, parent)
+{
+}
+
+bool QQSound::play(const QString & filename)
+{
+    QFileInfo fi(filename);
+    fi.makeAbsolute();
+    if ( ! fi.exists()) return false;
+    QString fn(fi.absoluteFilePath());
+    fn = QDir::toNativeSeparators(fn);
+    QSound::play(fn);
+    return true;
+}

pool/shard006/C++/0083843_getcomputername.cpp

@@ -0,0 +1,45 @@
+//! @file getcomputername.cpp
+//! @author George Fleming <v-geflem@microsoft>
+//! @brief Implements GetComputerName Win32 API
+
+#include <errno.h>
+#include <unistd.h>
+#include <string>
+#include "getcomputername.h"
+
+//! @brief GetComputerName retrieves the name of the host associated with
+//! the current thread.
+//!
+//! @exception errno Passes these errors via errno to GetLastError:
+//! - ERROR_INVALID_FUNCTION: getlogin_r() returned an unrecognized error code
+//! - ERROR_INVALID_ADDRESS: buffer is an invalid address
+//! - ERROR_GEN_FAILURE: buffer not large enough
+//!
+//! @retval username as UTF-8 string, or null if unsuccessful
+
+char* GetComputerName()
+{
+    errno = 0; 
+    // Get computername from system, note that gethostname(2) gets the
+    // nodename from uname
+    std::string computername(_POSIX_HOST_NAME_MAX, 0);
+    int err = gethostname(&computername[0], computername.length());
+    // Map errno to Win32 Error Codes
+    if (err != 0) 
+    {
+        switch (errno) 
+        {
+            case EFAULT:
+                errno = ERROR_INVALID_ADDRESS;
+                break;
+            case ENAMETOOLONG:
+                errno = ERROR_GEN_FAILURE;
+                break; 
+            default:
+                errno = ERROR_INVALID_FUNCTION;
+        }
+        return NULL;
+    }
+    
+    return strdup(computername.c_str());
+}

pool/shard006/C++/0083849_SdFatUtil.cpp

@@ -0,0 +1,74 @@
+/* Arduino SdFat Library
+ * Copyright (C) 2008 by William Greiman
+ *
+ * This file is part of the Arduino SdFat Library
+ *
+ * This Library is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This Library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with the Arduino SdFat Library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+#include <SdFatUtil.h>
+//------------------------------------------------------------------------------
+/** Amount of free RAM
+ * \return The number of free bytes.
+ */
+int SdFatUtil::FreeRam() {
+  extern int  __bss_end;
+  extern int* __brkval;
+  int free_memory;
+  if (reinterpret_cast<int>(__brkval) == 0) {
+    // if no heap use from end of bss section
+    free_memory = reinterpret_cast<int>(&free_memory)
+                  - reinterpret_cast<int>(&__bss_end);
+  } else {
+    // use from top of stack to heap
+    free_memory = reinterpret_cast<int>(&free_memory)
+                  - reinterpret_cast<int>(__brkval);
+  }
+  return free_memory;
+}
+//------------------------------------------------------------------------------
+/** %Print a string in flash memory.
+ *
+ * \param[in] pr Print object for output.
+ * \param[in] str Pointer to string stored in flash memory.
+ */
+void SdFatUtil::print_P(Print* pr, PGM_P str) {
+  for (uint8_t c; (c = pgm_read_byte(str)); str++) pr->print(c);
+}
+//------------------------------------------------------------------------------
+/** %Print a string in flash memory followed by a CR/LF.
+ *
+ * \param[in] pr Print object for output.
+ * \param[in] str Pointer to string stored in flash memory.
+ */
+void SdFatUtil::println_P(Print* pr, PGM_P str) {
+  print_P(pr, str);
+  pr->println();
+}
+//------------------------------------------------------------------------------
+/** %Print a string in flash memory to Serial.
+ *
+ * \param[in] str Pointer to string stored in flash memory.
+ */
+void SdFatUtil::SerialPrint_P(PGM_P str) {
+  print_P(&Serial, str);
+}
+//------------------------------------------------------------------------------
+/** %Print a string in flash memory to Serial followed by a CR/LF.
+ *
+ * \param[in] str Pointer to string stored in flash memory.
+ */
+void SdFatUtil::SerialPrintln_P(PGM_P str) {
+  println_P(&Serial, str);
+}

pool/shard006/C++/0083856_service_manager.cc

@@ -0,0 +1,123 @@
+// This file is part of SWGANH which is released under the MIT license.
+// See file LICENSE or go to http://swganh.com/LICENSE
+
+#include "service_manager.h"
+
+#include "anh/logger.h"
+
+#include <algorithm>
+#include <string>
+#include <stdexcept>
+
+#include "service_directory_interface.h"
+#include "service_description.h"
+
+#ifndef WIN32
+#include <boost/regex.hpp>
+using boost::regex;
+using boost::regex_search;
+#else
+#include <regex>
+using std::regex;
+using std::regex_search;
+#endif
+
+using namespace swganh::service;
+using namespace std;
+
+ServiceManager::ServiceManager(ServiceDirectoryInterface* service_directory)
+    : service_directory_(service_directory)
+{}
+
+ServiceManager::~ServiceManager()
+{
+	auto it = services_.begin();
+    for(it = services_.begin();it != services_.end();it++)
+    {
+		
+		service_directory_->removeService((it)->second->GetServiceDescription());
+    }
+}
+
+ServiceInterface* ServiceManager::GetService(string name)
+{
+    auto it = services_.find(name);
+
+    if (it == services_.end())
+    {
+        return nullptr;
+    }
+
+    return it->second.get();
+}
+
+void ServiceManager::AddService(string name, shared_ptr<ServiceInterface> service)
+{
+    auto current_service = GetService(name);
+
+    if (current_service)
+    {
+        // throw exception here, service already exists
+        throw std::runtime_error("service already exists: " + name);
+        return;
+    }
+
+    auto& service_description = service->GetServiceDescription();
+    if (!service_directory_->registerService(service_description))
+    {
+        throw std::runtime_error("Unable to register service " + service_description.name());
+    }
+
+    // update the status of the service
+    service_description.status(swganh::service::Galaxy::LOADING);
+    service_directory_->updateService(service_description);
+
+    services_[name] = service;
+}
+
+void ServiceManager::Start()
+{
+    // First pass initialization
+//for (auto& service_entry : services_)
+
+	auto it = services_.begin();
+    for(it = services_.begin();it != services_.end();it++)
+    {
+        auto& service = it->second;
+        service->Initialize();
+    }
+
+    // After all resources are acquired services can be started
+	//for (auto& service_entry : services_)
+    //{
+	it = services_.begin();
+    for(it = services_.begin();it != services_.end();it++)
+    {
+
+        auto& service = it->second;
+
+        service->Startup();
+        service->SetStatus(Galaxy::ONLINE);
+
+        auto service_description = service->GetServiceDescription();
+        service_directory_->updateService(service_description);
+        LOG(info) << "Started " << service_description.name();
+    }
+}
+
+void ServiceManager::Stop()
+{
+//for (auto& service_entry : services_)
+	auto it = services_.begin();
+    for(it = services_.begin();it != services_.end();it++)
+    {
+        auto& service = it->second;
+
+        service->Shutdown();
+        service->SetStatus(Galaxy::OFFLINE);
+
+        auto service_description = service->GetServiceDescription();
+        service_directory_->updateService(service_description);
+        LOG(info) << "Stopped " << service_description.name();
+    }
+}

pool/shard006/C++/0083858_Pawn.cpp

@@ -0,0 +1,163 @@
+#include "Pawn.h"
+#include "Board.h"
+
+
+
+
+Pawn::Pawn(Coordinate coordinate) : hasYetToMove(true)
+{
+	symbol = "";
+	this->coordinate = coordinate;
+	texture.loadFromFile("WhitePawn.png");
+	setTexture(texture);
+
+
+	int row = (int)coordinate / 8;
+	int column = (int)coordinate % 8;
+
+	//sf::RectangleShape::setPosition(sf::Vector2f(column * 50, 350 - row * 50));
+	setPosition(sf::Vector2f(column * 50, 350 - row * 50));
+	//setSize(sf::Vector2f(20, 20));
+}
+
+void Pawn::setCoordinate(const Coordinate position)
+{
+	Piece::setCoordinate(position);
+	hasYetToMove = false;
+}
+
+void Pawn::setIsWhite(const bool isWhite)
+{
+	this->isWhite = isWhite;
+
+	if (isWhite)
+	{
+		texture.loadFromFile("WhitePawn.png");
+	}
+	else
+	{
+		texture.loadFromFile("BlackPawn.png");
+	}
+	setTexture(texture);
+}
+
+
+
+std::vector<Coordinate> Pawn::computeMoves()
+{
+	//first clear past movablePositions
+	clearMoves();
+
+	//REQUIRES CHANGING TO ACCOUNT FOR and promotions. 
+
+	if (isWhite)
+	{
+		//capturing 1 up, 1 right piece
+		Coordinate upRight = CoordinateHelper::getCoordinateUpRight(coordinate);
+
+		if (upRight != CoordinateHelper::getMostUpRightCoordinate(coordinate) || upRight != Coordinate::Invalid)
+		{
+			addCaptureMove(upRight);
+		}
+
+		//capturing 1 up, 1 left piece
+		auto upLeft = CoordinateHelper::getCoordinateUpLeft(coordinate);
+
+		if (upLeft != CoordinateHelper::getMostUpLeftCoordinate(coordinate) || upLeft != Coordinate::Invalid)
+		{
+			addCaptureMove(upLeft);
+		}
+
+		auto oneUp = CoordinateHelper::getCoordinateUp(coordinate);
+		auto twoUp = CoordinateHelper::getCoordinateUp(oneUp);
+
+		//moving
+		if (hasYetToMove)
+		{
+			if (board[oneUp].getPiece() != nullptr)
+			{
+				//don't add any positions to computePosition
+			}
+			else if (board[oneUp].getPiece() == nullptr && board[twoUp].getPiece() != nullptr)
+			{
+				moves.push_back(oneUp);
+			}
+			else if (board[oneUp].getPiece() == nullptr && board[twoUp].getPiece() == nullptr)
+			{
+				moves.push_back(oneUp);
+				moves.push_back(twoUp);
+			}
+		}
+		else
+		{
+			if (board[oneUp].getPiece() == nullptr)
+			{
+				moves.push_back(oneUp);
+			}
+		}
+	}
+
+	else
+	{
+		//capturing 1 down, 1 right piece
+		auto downRight = CoordinateHelper::getCoordinateDownRight(coordinate);
+
+		if (downRight != CoordinateHelper::getMostDownRightCoordinate(coordinate) || downRight != Coordinate::Invalid)
+		{
+			addCaptureMove(downRight);
+		}
+
+		//capturing 1 down, 1 left piece
+		auto downLeft = CoordinateHelper::getCoordinateDownLeft(coordinate);
+
+		if (downLeft != CoordinateHelper::getMostDownLeftCoordinate(coordinate) ||	downLeft != Coordinate::Invalid)
+		{
+			addCaptureMove(downLeft);
+		}
+
+		auto oneDown = CoordinateHelper::getCoordinateDown(coordinate);
+		auto twoDown = CoordinateHelper::getCoordinateDown(oneDown);
+
+		//moving
+		if (hasYetToMove)
+		{
+			if (board[oneDown].getPiece() != nullptr)
+			{
+				//don't add any positions to computePosition
+			}
+			else if (board[oneDown].getPiece() == nullptr && board[twoDown].getPiece() != nullptr)
+			{
+				moves.push_back(oneDown);
+			}
+			else if (board[oneDown].getPiece() == nullptr && board[twoDown].getPiece() == nullptr)
+			{
+				moves.push_back(oneDown);
+				moves.push_back(twoDown);
+			}
+		}
+		else
+		{
+			if (board[oneDown].getPiece() == nullptr)
+			{
+				moves.push_back(oneDown);
+			}
+		}
+	}
+
+	return moves;
+}
+
+
+void Pawn::addCaptureMove(const Coordinate& coordinate)
+{
+	if (board[coordinate].getPiece() != nullptr)
+	{
+		if (board[coordinate].getPiece()->getIsWhite() != this->isWhite)
+		{
+			moves.push_back(coordinate);
+
+		}
+	}
+}
+
+