Upload folder using huggingface_hub (part 72)

pool/shard006/C++/0078449_pagelocker.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "support/pagelocker.h"
+
+#if defined(HAVE_CONFIG_H)
+#include "config/mxn-config.h"
+#endif
+
+#ifdef WIN32
+#ifdef _WIN32_WINNT
+#undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0501
+#define WIN32_LEAN_AND_MEAN 1
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+// This is used to attempt to keep keying material out of swap
+// Note that VirtualLock does not provide this as a guarantee on Windows,
+// but, in practice, memory that has been VirtualLock'd almost never gets written to
+// the pagefile except in rare circumstances where memory is extremely low.
+#else
+#include <sys/mman.h>
+#include <limits.h> // for PAGESIZE
+#include <unistd.h> // for sysconf
+#endif
+
+LockedPageManager* LockedPageManager::_instance = NULL;
+boost::once_flag LockedPageManager::init_flag = BOOST_ONCE_INIT;
+
+/** Determine system page size in bytes */
+static inline size_t GetSystemPageSize()
+{
+    size_t page_size;
+#if defined(WIN32)
+    SYSTEM_INFO sSysInfo;
+    GetSystemInfo(&sSysInfo);
+    page_size = sSysInfo.dwPageSize;
+#elif defined(PAGESIZE) // defined in limits.h
+    page_size = PAGESIZE;
+#else                   // assume some POSIX OS
+    page_size = sysconf(_SC_PAGESIZE);
+#endif
+    return page_size;
+}
+
+bool MemoryPageLocker::Lock(const void* addr, size_t len)
+{
+#ifdef WIN32
+    return VirtualLock(const_cast<void*>(addr), len) != 0;
+#else
+    return mlock(addr, len) == 0;
+#endif
+}
+
+bool MemoryPageLocker::Unlock(const void* addr, size_t len)
+{
+#ifdef WIN32
+    return VirtualUnlock(const_cast<void*>(addr), len) != 0;
+#else
+    return munlock(addr, len) == 0;
+#endif
+}
+
+LockedPageManager::LockedPageManager() : LockedPageManagerBase<MemoryPageLocker>(GetSystemPageSize())
+{
+}

pool/shard006/C++/0078462_memory_details_android.cc

@@ -0,0 +1,142 @@
+// 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 "chrome/browser/memory_details.h"
+
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/process/process_iterator.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/grit/chromium_strings.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/process_type.h"
+#include "ui/base/l10n/l10n_util.h"
+
+using base::ProcessEntry;
+using base::ProcessId;
+using content::BrowserThread;
+
+namespace {
+
+// A helper for |CollectProcessData()| to include the chrome sandboxed
+// processes in android which are not running as a child of the browser
+// process.
+void AddNonChildChromeProcesses(
+    std::vector<ProcessMemoryInformation>* processes) {
+  base::ProcessIterator process_iter(NULL);
+  while (const ProcessEntry* process_entry = process_iter.NextProcessEntry()) {
+    const std::vector<std::string>& cmd_args = process_entry->cmd_line_args();
+    if (cmd_args.empty() ||
+        cmd_args[0].find(chrome::kHelperProcessExecutableName) ==
+            std::string::npos) {
+      continue;
+    }
+    ProcessMemoryInformation info;
+    info.pid = process_entry->pid();
+    processes->push_back(info);
+  }
+}
+
+// For each of the pids, collect memory information about that process
+// and append a record to |out|.
+void GetProcessDataMemoryInformation(
+    const std::set<ProcessId>& pids, ProcessData* out) {
+  for (std::set<ProcessId>::const_iterator i = pids.begin(); i != pids.end();
+       ++i) {
+    ProcessMemoryInformation pmi;
+
+    pmi.pid = *i;
+    pmi.num_processes = 1;
+
+    if (pmi.pid == base::GetCurrentProcId())
+      pmi.process_type = content::PROCESS_TYPE_BROWSER;
+    else
+      pmi.process_type = content::PROCESS_TYPE_UNKNOWN;
+
+    scoped_ptr<base::ProcessMetrics> metrics(
+        base::ProcessMetrics::CreateProcessMetrics(*i));
+    metrics->GetWorkingSetKBytes(&pmi.working_set);
+
+    out->processes.push_back(pmi);
+  }
+}
+
+// Find all children of the given process.
+void GetAllChildren(const std::vector<ProcessEntry>& processes,
+                    const std::set<ProcessId>& roots,
+                    std::set<ProcessId>* out) {
+  *out = roots;
+
+  std::set<ProcessId> wavefront;
+  for (std::set<ProcessId>::const_iterator i = roots.begin(); i != roots.end();
+       ++i) {
+    wavefront.insert(*i);
+  }
+
+  while (wavefront.size()) {
+    std::set<ProcessId> next_wavefront;
+    for (std::vector<ProcessEntry>::const_iterator i = processes.begin();
+         i != processes.end(); ++i) {
+      if (wavefront.count(i->parent_pid())) {
+        out->insert(i->pid());
+        next_wavefront.insert(i->pid());
+      }
+    }
+
+    wavefront.clear();
+    wavefront.swap(next_wavefront);
+  }
+}
+
+}  // namespace
+
+MemoryDetails::MemoryDetails()
+    : user_metrics_mode_(UPDATE_USER_METRICS),
+      memory_growth_tracker_(NULL) {
+}
+
+ProcessData* MemoryDetails::ChromeBrowser() {
+  return &process_data_[0];
+}
+
+void MemoryDetails::CollectProcessData(
+    const std::vector<ProcessMemoryInformation>& chrome_processes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  std::vector<ProcessMemoryInformation> all_processes(chrome_processes);
+  AddNonChildChromeProcesses(&all_processes);
+
+  std::vector<ProcessEntry> processes;
+  base::ProcessIterator process_iter(NULL);
+  while (const ProcessEntry* process_entry = process_iter.NextProcessEntry()) {
+    processes.push_back(*process_entry);
+  }
+
+  std::set<ProcessId> roots;
+  roots.insert(base::GetCurrentProcId());
+  for (std::vector<ProcessMemoryInformation>::const_iterator
+       i = all_processes.begin(); i != all_processes.end(); ++i) {
+    roots.insert(i->pid);
+  }
+
+  std::set<ProcessId> current_browser_processes;
+  GetAllChildren(processes, roots, &current_browser_processes);
+
+  ProcessData current_browser;
+  GetProcessDataMemoryInformation(current_browser_processes, &current_browser);
+  current_browser.name = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
+  current_browser.process_name =
+      base::ASCIIToUTF16(chrome::kBrowserProcessExecutableName);
+  process_data_.push_back(current_browser);
+
+  // Finally return to the browser thread.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&MemoryDetails::CollectChildInfoOnUIThread, this));
+}

pool/shard006/C++/0078464_native_test_launcher.cc

@@ -0,0 +1,153 @@
+// 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.
+
+// This class sets up the environment for running the native tests inside an
+// android application. It outputs (to a fifo) markers identifying the
+// START/PASSED/CRASH of the test suite, FAILURE/SUCCESS of individual tests,
+// etc.
+// These markers are read by the test runner script to generate test results.
+// It installs signal handlers to detect crashes.
+
+#include <android/log.h>
+#include <signal.h>
+
+#include "base/android/base_jni_registrar.h"
+#include "base/android/context_utils.h"
+#include "base/android/fifo_utils.h"
+#include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/at_exit.h"
+#include "base/base_switches.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "gtest/gtest.h"
+#include "jni/NativeTestActivity_jni.h"
+#include "testing/android/native_test/native_test_util.h"
+
+// The main function of the program to be wrapped as a test apk.
+extern int main(int argc, char** argv);
+
+namespace testing {
+namespace android {
+
+namespace {
+
+const char kLogTag[] = "chromium";
+const char kCrashedMarker[] = "[ CRASHED      ]\n";
+
+// The list of signals which are considered to be crashes.
+const int kExceptionSignals[] = {
+  SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, -1
+};
+
+struct sigaction g_old_sa[NSIG];
+
+// This function runs in a compromised context. It should not allocate memory.
+void SignalHandler(int sig, siginfo_t* info, void* reserved) {
+  // Output the crash marker.
+  write(STDOUT_FILENO, kCrashedMarker, sizeof(kCrashedMarker));
+  g_old_sa[sig].sa_sigaction(sig, info, reserved);
+}
+
+// Writes printf() style string to Android's logger where |priority| is one of
+// the levels defined in <android/log.h>.
+void AndroidLog(int priority, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  __android_log_vprint(priority, kLogTag, format, args);
+  va_end(args);
+}
+
+}  // namespace
+
+static void RunTests(JNIEnv* env,
+                     const JavaParamRef<jobject>& obj,
+                     const JavaParamRef<jstring>& jcommand_line_flags,
+                     const JavaParamRef<jstring>& jcommand_line_file_path,
+                     const JavaParamRef<jstring>& jstdout_file_path,
+                     jboolean jstdout_fifo,
+                     const JavaParamRef<jobject>& app_context) {
+  // Command line initialized basically, will be fully initialized later.
+  static const char* const kInitialArgv[] = { "ChromeTestActivity" };
+  base::CommandLine::Init(arraysize(kInitialArgv), kInitialArgv);
+
+  std::vector<std::string> args;
+
+  const std::string command_line_file_path(
+      base::android::ConvertJavaStringToUTF8(env, jcommand_line_file_path));
+  if (command_line_file_path.empty())
+    args.push_back("_");
+  else
+    ParseArgsFromCommandLineFile(command_line_file_path.c_str(), &args);
+
+  const std::string command_line_flags(
+      base::android::ConvertJavaStringToUTF8(env, jcommand_line_flags));
+  ParseArgsFromString(command_line_flags, &args);
+
+  std::vector<char*> argv;
+  int argc = ArgsToArgv(args, &argv);
+
+  // Fully initialize command line with arguments.
+  base::CommandLine::ForCurrentProcess()->AppendArguments(
+      base::CommandLine(argc, &argv[0]), false);
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+
+  base::FilePath stdout_file_path(
+      base::android::ConvertJavaStringToUTF8(env, jstdout_file_path));
+
+  // A few options, such "--gtest_list_tests", will just use printf directly
+  // Always redirect stdout to a known file.
+  unlink(stdout_file_path.value().c_str());
+  if (jstdout_fifo) {
+    if (!base::android::CreateFIFO(stdout_file_path, 0666)) {
+      AndroidLog(ANDROID_LOG_ERROR, "Failed to create fifo %s: %s\n",
+                 stdout_file_path.value().c_str(), strerror(errno));
+      exit(EXIT_FAILURE);
+    }
+  }
+  if (!base::android::RedirectStream(stdout, stdout_file_path, "w+")) {
+    AndroidLog(ANDROID_LOG_ERROR, "Failed to redirect stream to file: %s: %s\n",
+               stdout_file_path.value().c_str(), strerror(errno));
+    exit(EXIT_FAILURE);
+  }
+  dup2(STDOUT_FILENO, STDERR_FILENO);
+
+  if (command_line.HasSwitch(switches::kWaitForDebugger)) {
+    AndroidLog(ANDROID_LOG_VERBOSE,
+               "Native test waiting for GDB because flag %s was supplied",
+               switches::kWaitForDebugger);
+    base::debug::WaitForDebugger(24 * 60 * 60, false);
+  }
+
+  ScopedMainEntryLogger scoped_main_entry_logger;
+  main(argc, &argv[0]);
+}
+
+bool RegisterNativeTestJNI(JNIEnv* env) {
+  if (!base::android::RegisterJni(env)) {
+    return false;
+  }
+  return RegisterNativesImpl(env);
+}
+
+// TODO(nileshagrawal): now that we're using FIFO, test scripts can detect EOF.
+// Remove the signal handlers.
+void InstallHandlers() {
+  struct sigaction sa;
+  memset(&sa, 0, sizeof(sa));
+
+  sa.sa_sigaction = SignalHandler;
+  sa.sa_flags = SA_SIGINFO;
+
+  for (unsigned int i = 0; kExceptionSignals[i] != -1; ++i) {
+    sigaction(kExceptionSignals[i], &sa, &g_old_sa[kExceptionSignals[i]]);
+  }
+}
+
+}  // namespace android
+}  // namespace testing

pool/shard006/C++/0078473_instantiation_test.cpp

@@ -0,0 +1,81 @@
+#include"all_defines.hpp"
+#include"objects.hpp"
+#include"heaps.hpp"
+#include"types.hpp"
+
+#include<iostream>
+#include<cassert>
+
+class MyHeap : public Heap {
+protected:
+	virtual void scan_root_object(GenericTraverser* gt) {
+		gt->traverse(r0);
+		gt->traverse(r1);
+	}
+public:
+	Object::ref r0;
+	Object::ref r1;
+	explicit MyHeap(size_t sz) : Heap(sz) { }
+};
+
+class HlError {
+public:
+	char const* val;
+	explicit HlError(char const* nval) : val(nval) { }
+};
+
+void throw_HlError(char const* t) {
+	throw HlError(t);
+}
+
+class OverBrokenHeart {
+public:
+	Generic* cause;
+	explicit OverBrokenHeart(Generic* ncause) : cause(ncause) { }
+};
+
+void throw_OverBrokenHeart(Generic* cause) {
+	throw OverBrokenHeart(cause);
+}
+
+struct RangeError {
+};
+struct TypeError {
+};
+
+void throw_RangeError(const char*) {
+	throw RangeError();
+}
+void throw_TypeError(Object::ref, const char*) {
+	throw TypeError();
+}
+
+struct DeallocError {
+};
+
+void throw_DeallocError(void*) {
+	throw DeallocError();
+}
+
+int main(void) {
+	MyHeap tmp(sizeof(Cons));
+
+	std::cout << "allocating 1st" << std::endl;
+	tmp.r0 = Object::to_ref<Generic*>(tmp.create<Cons>());
+	std::cout << "r0 = @" << as_a<Generic*>(tmp.r0) << std::endl;
+
+	std::cout << "allocating 2nd" << std::endl;
+	tmp.r1 = Object::to_ref<Generic*>(tmp.create<Cons>());
+	scar(tmp.r1, tmp.r0);
+	std::cout << "r0 = @" << as_a<Generic*>(tmp.r0) << std::endl;
+	std::cout << "r1 = @" << as_a<Generic*>(tmp.r1) << std::endl;
+	assert(car(tmp.r1) == tmp.r0);
+
+	std::cout << "allocating 3rd" << std::endl;
+	tmp.r1 = Object::to_ref<Generic*>(tmp.create<Cons>());
+	scdr(tmp.r0, tmp.r1);
+	std::cout << "r0 = @" << as_a<Generic*>(tmp.r0) << std::endl;
+	std::cout << "r1 = @" << as_a<Generic*>(tmp.r1) << std::endl;
+	assert(cdr(tmp.r0) == tmp.r1);
+}
+

pool/shard006/C++/0078478_moc_vscvideowall.cpp

@@ -0,0 +1,216 @@
+/****************************************************************************
+** Meta object code from reading C++ file 'vscvideowall.h'
+**
+** Created by: The Qt Meta Object Compiler version 67 (Qt 5.0.2)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "../../../vwidget/vscvideowall.h"
+#include <QtCore/qbytearray.h>
+#include <QtCore/qmetatype.h>
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'vscvideowall.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 67
+#error "This file was generated using the moc from 5.0.2. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+struct qt_meta_stringdata_VSCVideoWall_t {
+    QByteArrayData data[15];
+    char stringdata[224];
+};
+#define QT_MOC_LITERAL(idx, ofs, len) \
+    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
+    offsetof(qt_meta_stringdata_VSCVideoWall_t, stringdata) + ofs \
+        - idx * sizeof(QByteArrayData) \
+    )
+static const qt_meta_stringdata_VSCVideoWall_t qt_meta_stringdata_VSCVideoWall = {
+    {
+QT_MOC_LITERAL(0, 0, 12),
+QT_MOC_LITERAL(1, 13, 18),
+QT_MOC_LITERAL(2, 32, 0),
+QT_MOC_LITERAL(3, 33, 3),
+QT_MOC_LITERAL(4, 37, 19),
+QT_MOC_LITERAL(5, 57, 17),
+QT_MOC_LITERAL(6, 75, 16),
+QT_MOC_LITERAL(7, 92, 14),
+QT_MOC_LITERAL(8, 107, 16),
+QT_MOC_LITERAL(9, 124, 16),
+QT_MOC_LITERAL(10, 141, 16),
+QT_MOC_LITERAL(11, 158, 16),
+QT_MOC_LITERAL(12, 175, 14),
+QT_MOC_LITERAL(13, 190, 17),
+QT_MOC_LITERAL(14, 208, 14)
+    },
+    "VSCVideoWall\0ShowDisplayClicked\0\0nId\0"
+    "ShowFloatingClicked\0ShowTabbedClicked\0"
+    "ShowFocusClicked\0floatingAction\0"
+    "unFloatingAction\0SetLayoutMode4x4\0"
+    "SetLayoutMode3x3\0SetLayoutMode2x2\0"
+    "SetLayoutMode6\0SetLayoutMode12p1\0"
+    "SetLayoutMode1\0"
+};
+#undef QT_MOC_LITERAL
+
+static const uint qt_meta_data_VSCVideoWall[] = {
+
+ // content:
+       7,       // revision
+       0,       // classname
+       0,    0, // classinfo
+      12,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       4,       // signalCount
+
+ // signals: name, argc, parameters, tag, flags
+       1,    1,   74,    2, 0x05,
+       4,    0,   77,    2, 0x05,
+       5,    0,   78,    2, 0x05,
+       6,    1,   79,    2, 0x05,
+
+ // slots: name, argc, parameters, tag, flags
+       7,    0,   82,    2, 0x0a,
+       8,    0,   83,    2, 0x0a,
+       9,    0,   84,    2, 0x0a,
+      10,    0,   85,    2, 0x0a,
+      11,    0,   86,    2, 0x0a,
+      12,    0,   87,    2, 0x0a,
+      13,    0,   88,    2, 0x0a,
+      14,    0,   89,    2, 0x0a,
+
+ // signals: parameters
+    QMetaType::Void, QMetaType::Int,    3,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void, QMetaType::Int,    3,
+
+ // slots: parameters
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+
+       0        // eod
+};
+
+void VSCVideoWall::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        VSCVideoWall *_t = static_cast<VSCVideoWall *>(_o);
+        switch (_id) {
+        case 0: _t->ShowDisplayClicked((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 1: _t->ShowFloatingClicked(); break;
+        case 2: _t->ShowTabbedClicked(); break;
+        case 3: _t->ShowFocusClicked((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 4: _t->floatingAction(); break;
+        case 5: _t->unFloatingAction(); break;
+        case 6: _t->SetLayoutMode4x4(); break;
+        case 7: _t->SetLayoutMode3x3(); break;
+        case 8: _t->SetLayoutMode2x2(); break;
+        case 9: _t->SetLayoutMode6(); break;
+        case 10: _t->SetLayoutMode12p1(); break;
+        case 11: _t->SetLayoutMode1(); break;
+        default: ;
+        }
+    } else if (_c == QMetaObject::IndexOfMethod) {
+        int *result = reinterpret_cast<int *>(_a[0]);
+        void **func = reinterpret_cast<void **>(_a[1]);
+        {
+            typedef void (VSCVideoWall::*_t)(int );
+            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&VSCVideoWall::ShowDisplayClicked)) {
+                *result = 0;
+            }
+        }
+        {
+            typedef void (VSCVideoWall::*_t)();
+            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&VSCVideoWall::ShowFloatingClicked)) {
+                *result = 1;
+            }
+        }
+        {
+            typedef void (VSCVideoWall::*_t)();
+            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&VSCVideoWall::ShowTabbedClicked)) {
+                *result = 2;
+            }
+        }
+        {
+            typedef void (VSCVideoWall::*_t)(int );
+            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&VSCVideoWall::ShowFocusClicked)) {
+                *result = 3;
+            }
+        }
+    }
+}
+
+const QMetaObject VSCVideoWall::staticMetaObject = {
+    { &QWidget::staticMetaObject, qt_meta_stringdata_VSCVideoWall.data,
+      qt_meta_data_VSCVideoWall,  qt_static_metacall, 0, 0}
+};
+
+
+const QMetaObject *VSCVideoWall::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
+}
+
+void *VSCVideoWall::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_VSCVideoWall.stringdata))
+        return static_cast<void*>(const_cast< VSCVideoWall*>(this));
+    return QWidget::qt_metacast(_clname);
+}
+
+int VSCVideoWall::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 12)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 12;
+    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
+        if (_id < 12)
+            *reinterpret_cast<int*>(_a[0]) = -1;
+        _id -= 12;
+    }
+    return _id;
+}
+
+// SIGNAL 0
+void VSCVideoWall::ShowDisplayClicked(int _t1)
+{
+    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
+    QMetaObject::activate(this, &staticMetaObject, 0, _a);
+}
+
+// SIGNAL 1
+void VSCVideoWall::ShowFloatingClicked()
+{
+    QMetaObject::activate(this, &staticMetaObject, 1, 0);
+}
+
+// SIGNAL 2
+void VSCVideoWall::ShowTabbedClicked()
+{
+    QMetaObject::activate(this, &staticMetaObject, 2, 0);
+}
+
+// SIGNAL 3
+void VSCVideoWall::ShowFocusClicked(int _t1)
+{
+    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
+    QMetaObject::activate(this, &staticMetaObject, 3, _a);
+}
+QT_END_MOC_NAMESPACE

pool/shard006/C++/0078481_PurchaseHostReservationRequest.cpp

@@ -0,0 +1,76 @@
+/*
+* 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/ec2/model/PurchaseHostReservationRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::EC2::Model;
+using namespace Aws::Utils;
+
+PurchaseHostReservationRequest::PurchaseHostReservationRequest() : 
+    m_offeringIdHasBeenSet(false),
+    m_hostIdSetHasBeenSet(false),
+    m_limitPriceHasBeenSet(false),
+    m_currencyCode(CurrencyCodeValues::NOT_SET),
+    m_currencyCodeHasBeenSet(false),
+    m_clientTokenHasBeenSet(false)
+{
+}
+
+Aws::String PurchaseHostReservationRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=PurchaseHostReservation&";
+  if(m_offeringIdHasBeenSet)
+  {
+    ss << "OfferingId=" << StringUtils::URLEncode(m_offeringId.c_str()) << "&";
+  }
+
+  if(m_hostIdSetHasBeenSet)
+  {
+    unsigned hostIdSetCount = 1;
+    for(auto& item : m_hostIdSet)
+    {
+      ss << "HostIdSet." << hostIdSetCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      hostIdSetCount++;
+    }
+  }
+
+  if(m_limitPriceHasBeenSet)
+  {
+    ss << "LimitPrice=" << StringUtils::URLEncode(m_limitPrice.c_str()) << "&";
+  }
+
+  if(m_currencyCodeHasBeenSet)
+  {
+    ss << "CurrencyCode=" << CurrencyCodeValuesMapper::GetNameForCurrencyCodeValues(m_currencyCode) << "&";
+  }
+
+  if(m_clientTokenHasBeenSet)
+  {
+    ss << "ClientToken=" << StringUtils::URLEncode(m_clientToken.c_str()) << "&";
+  }
+
+  ss << "Version=2016-11-15";
+  return ss.str();
+}
+
+
+void  PurchaseHostReservationRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

pool/shard006/C++/0078487_systemmodel.cpp

@@ -0,0 +1,186 @@
+/***************************************************************************
+ *   Copyright (C) 2014 by Eike Hein <hein@kde.org>                   *
+ *                                                                         *
+ *   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 "systemmodel.h"
+#include "actionlist.h"
+
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusPendingCall>
+
+#include <KAuthorized>
+#include <KConfigGroup>
+#include <KLocalizedString>
+#include <KSharedConfig>
+#include <kworkspace.h>
+#include <Solid/PowerManagement>
+#include "ksmserver_interface.h"
+
+SystemEntry::SystemEntry(SystemEntry::Action action, const QString &name, const QString &icon)
+{
+    m_action = action;
+    m_name = name;
+    m_icon = QIcon::fromTheme(icon, QIcon::fromTheme("unknown"));
+}
+
+SystemModel::SystemModel(QObject *parent) : AbstractModel(parent)
+{
+    m_favoriteIds[SystemEntry::LockSession] = "lock-screen";
+    m_favoriteIds[SystemEntry::LogoutSession] = "logout";
+    m_favoriteIds[SystemEntry::SaveSession] = "save-session";
+    m_favoriteIds[SystemEntry::NewSession] = "switch-user";
+    m_favoriteIds[SystemEntry::SuspendToRam] = "suspend";
+    m_favoriteIds[SystemEntry::SuspendToDisk] = "hibernate";
+    m_favoriteIds[SystemEntry::Reboot] = "reboot";
+    m_favoriteIds[SystemEntry::Shutdown] = "shutdown";
+
+    if (KAuthorized::authorizeKAction("lock_screen")) {
+        m_entryList << new SystemEntry(SystemEntry::LockSession, i18n("Lock"), "system-lock-screen");
+    }
+
+    if (KAuthorized::authorizeKAction("logout") && KAuthorized::authorize("logout")) {
+        m_entryList << new SystemEntry(SystemEntry::LogoutSession, i18n("Logout"), "system-log-out");
+
+        const KConfigGroup c(KSharedConfig::openConfig("ksmserverrc", KConfig::NoGlobals), "General");
+
+        if (c.readEntry("loginMode") == "restoreSavedSession") {
+            m_entryList << new SystemEntry(SystemEntry::SaveSession, i18n("Save Session"), "system-save-session");
+        }
+    }
+
+    if (KAuthorized::authorizeKAction("start_new_session")
+        && m_displayManager.isSwitchable()
+        && m_displayManager.numReserve() >= 0) {
+        m_entryList << new SystemEntry(SystemEntry::NewSession, i18n("New Session"), "system-switch-user");
+    }
+
+    QSet<Solid::PowerManagement::SleepState> sleepStates = Solid::PowerManagement::supportedSleepStates();
+
+    if (KAuthorized::authorizeKAction("logout") && KAuthorized::authorize("logout")) {
+      if (sleepStates.contains(Solid::PowerManagement::SuspendState)) {
+	  m_entryList << new SystemEntry(SystemEntry::SuspendToRam, i18n("Suspend"), "system-suspend");
+      }
+
+      if (sleepStates.contains(Solid::PowerManagement::HibernateState)) {
+	  m_entryList << new SystemEntry(SystemEntry::SuspendToDisk, i18n("Hibernate"), "system-suspend-hibernate");
+      }
+    }
+
+    m_entryList << new SystemEntry(SystemEntry::Reboot, i18n("Restart"), "system-reboot");
+    m_entryList << new SystemEntry(SystemEntry::Shutdown, i18n("Shutdown"), "system-shutdown");
+}
+
+SystemModel::~SystemModel()
+{
+    qDeleteAll(m_entryList);
+}
+
+QVariant SystemModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= m_entryList.count()) {
+        return QVariant();
+    }
+
+    if (role == Qt::DisplayRole) {
+        return m_entryList.at(index.row())->name();
+    } else if (role == Qt::DecorationRole) {
+        return m_entryList.at(index.row())->iconName();
+    } else if (role == Kicker::FavoriteIdRole) {
+        return QVariant("sys:" + m_favoriteIds[m_entryList.at(index.row())->action()]);
+    }
+
+    return QVariant();
+}
+
+int SystemModel::rowCount(const QModelIndex &parent) const
+{
+    return parent.isValid() ? 0 : m_entryList.count();
+}
+
+bool SystemModel::trigger(int row, const QString &actionId, const QVariant &argument)
+{
+    Q_UNUSED(actionId)
+    Q_UNUSED(argument)
+
+    if (row >= 0 && row < m_entryList.count()) {
+        SystemEntry::Action action = m_entryList.at(row)->action();
+
+        switch (action) {
+            case SystemEntry::LockSession:
+            {
+                QDBusConnection bus = QDBusConnection::sessionBus();
+                QDBusInterface interface("org.freedesktop.ScreenSaver", "/ScreenSaver", "org.freedesktop.ScreenSaver", bus);
+                interface.asyncCall("Lock");
+                break;
+            }
+            case SystemEntry::LogoutSession:
+                KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeNone);
+                break;
+            case SystemEntry::SaveSession:
+            {
+                org::kde::KSMServerInterface ksmserver(QStringLiteral("org.kde.ksmserver"),
+                    QStringLiteral("/KSMServer"), QDBusConnection::sessionBus());
+
+                if (ksmserver.isValid()) {
+                    ksmserver.saveCurrentSession();
+                }
+
+                break;
+            }
+            case SystemEntry::NewSession:
+            {
+                QDBusConnection bus = QDBusConnection::sessionBus();
+                QDBusInterface interface("org.freedesktop.ScreenSaver", "/ScreenSaver", "org.freedesktop.ScreenSaver", bus);
+                interface.asyncCall("Lock");
+                m_displayManager.startReserve();
+                break;
+            };
+            case SystemEntry::SuspendToRam:
+                Solid::PowerManagement::requestSleep(Solid::PowerManagement::SuspendState, 0, 0);
+                break;
+            case SystemEntry::SuspendToDisk:
+                Solid::PowerManagement::requestSleep(Solid::PowerManagement::HibernateState, 0, 0);
+                break;
+            case SystemEntry::Shutdown:
+                KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeHalt);
+                break;
+            case SystemEntry::Reboot:
+                KWorkSpace::requestShutDown(KWorkSpace::ShutdownConfirmDefault, KWorkSpace::ShutdownTypeReboot);
+                break;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+int SystemModel::rowForFavoriteId(const QString& favoriteId)
+{
+    const SystemEntry::Action action = m_favoriteIds.key(favoriteId);
+
+    for (int i = 0; i < m_entryList.count(); ++i) {
+        if (action == m_entryList.at(i)->action()) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+

pool/shard006/C++/0078490_mrlock.cpp

@@ -0,0 +1,124 @@
+// mrlock.cpp
+// author: Mr-Small
+#include <stdio.h>
+#include "mrlock.h"
+
+namespace mrio {
+
+// Constructor.
+MrLock::MrLock()
+  : lock_(false)
+  , lockHandle_(INVALID_HANDLE) {
+  createHandle();
+}
+
+// Destructor.
+MrLock::~MrLock() {
+  deleteHandle();
+}
+
+// Create handle for lock.
+void MrLock::createHandle() {
+
+#if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64)
+  // Create mutex handle.
+  lockHandle_ = CreateMutex(0, TRUE, NULL);
+#elif defined(ANDROID)
+  // Create semaphore.
+  lockHandle_ = new sem_t;
+  sem_init(lockHandle_, 0, 1);
+#else
+  // Create semaphore.
+  lockHandle_ = semget((key_t)1111, 1, 0666 | IPC_CREAT);
+  if (lockHandle_ != INVALID_HANDLE) {
+    union semuni semunion;
+    semunion.val = 1;
+    if (semctl(lockHandle_, 0, SETVAL, semunion) == -1) {
+      perror("create handle failed.");
+    }
+  }
+#endif // WIIN
+}
+
+// Delete handle for lock.
+void MrLock::deleteHandle() {
+
+  unlock();
+  if (lockHandle_ != INVALID_HANDLE) {
+#if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64)
+  // Check mutex.
+    CloseHandle(lockHandle_);
+#elif defined(ANDROID)
+    sem_destroy(lockHandle_);
+#else
+    union semuni semunion;
+    if (semctl(lockHandle_, 0, IPC_RMID, semunion) == -1) {
+      perror("delete handle failed.");
+    }
+#endif // WIN
+    lockHandle_ = INVALID_HANDLE;
+  }
+  lock_ = false;
+}
+
+// Lock with handle.
+bool MrLock::lock() {
+
+  if (lock_) {
+    return true;
+  }
+
+  if (lockHandle_ == INVALID_HANDLE) {
+    perror("lock handle invalid.");
+    return false;
+  }
+
+#if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64)
+
+  // Wait for single object.
+  if (WaitForSingleObject(lockHandle_, INFINITE) == WAIT_FAILED) {
+    perror("waitforsingleobject wait failed.");
+    return false;
+  }
+#elif defined(ANDROID)
+  sem_wait(lockHandle_);
+#else
+  // semaphore lock.
+  sembuf_.sem_num = 0;
+  sembuf_.sem_op = -1;
+  sembuf_.sem_flg = SEM_UNDO;
+
+  if (semop(lockHandle_, &sembuf_, 1) == -1) {
+    perror("semop failed.");
+  }
+#endif // WIN
+
+  lock_ = true;
+  return true;
+}
+
+// Unlock.
+void MrLock::unlock() {
+
+  if (!lock_) {
+    return;
+  }
+#if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64)
+  ReleaseMutex(lockHandle_);
+#elif defined(ANDROID)
+  sem_post(lockHandle_);
+#else
+  sembuf_.sem_op = 1;
+  if (semop(lockHandle_, &sembuf_, 1) == -1) {
+    perror("semop failed.");
+  }
+#endif // WIN
+  lock_ = false;
+}
+
+// Check locked.
+bool MrLock::isLocked() {
+  return lock_;
+}
+
+} // namespace mrio

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

@@ -0,0 +1,107 @@
+/* This file is part of Music Shelf
+ * Copyright (C) 2011 Martin Grimme  <martin.grimme _AT_ gmail.com>
+ *
+ * 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 <QGuiApplication>
+#include <QQuickView>
+#include <QtQml>
+#include <QQmlComponent>
+#include <QQmlContext>
+#include <QDir>
+#include <QDesktopServices>
+#include <QDebug>
+
+#include "context.h"
+#include "foldermodel.h"
+#include "mobilitybackend.h"
+
+#include "mediabox-core/abstractbackend.h"
+#include "mediabox-core/contentmodel.h"
+#include "mediabox-core/contentprovider.h"
+#include "mediabox-core/datadirectory.h"
+#include "mediabox-core/player.h"
+#include "mediabox-core/playqueue.h"
+
+#ifdef HAS_BOOSTER
+#include <MDeclarativeCache>
+#endif
+
+#ifdef HAS_BOOSTER
+Q_DECL_EXPORT
+#endif
+int main(int argc, char *argv[])
+{
+    QGuiApplication* application;
+    QQuickView* view;
+    
+    DataDirectory::initialize();
+#ifdef HAS_BOOSTER
+    application = MDeclarativeCache::qApplication(argc, argv);
+    view = MDeclarativeCache::qQuickView();
+#else
+    qWarning() << Q_FUNC_INFO << "Warning! Running without booster. This may be a bit slower.";
+    QGuiApplication stackApp(argc, argv);
+    QQuickView stackView;
+    application = &stackApp;
+    view = &stackView;
+#endif
+    QGuiApplication::setOrganizationDomain("org.nemomobile");
+    QGuiApplication::setOrganizationName("nemomobile");
+    application->setApplicationName("Music Player");
+    Context context;
+
+    media::Player player;
+    MobilityBackend backend;
+    player.registerBackend("mobility", &backend);
+    player.selectBackend("mobility");
+
+    qDebug() << "setting up playing queue";
+    media::PlayQueue *playQueue = new media::PlayQueue;
+    QGuiApplication::connect(playQueue, SIGNAL(itemChanged(content::File::Ptr)),
+                          &player, SLOT(load(content::File::Ptr)));
+    QGuiApplication::connect(&player, SIGNAL(eofReached()),
+                          playQueue, SLOT(next()));
+
+    FolderModel folderModel;
+
+    // export into QML world
+    view->rootContext()->setContextProperty("context", &context);
+    view->rootContext()->setContextProperty("folderModel", &folderModel);
+    view->rootContext()->setContextProperty("albumModel",
+                                      context.contentProvider()->createModel());
+    view->rootContext()->setContextProperty("tracksModel",
+                                      context.contentProvider()->createModel());
+    view->rootContext()->setContextProperty("player", &player);
+    view->rootContext()->setContextProperty("playQueue", playQueue);
+
+    view->setSource(QUrl("qrc:/qml/main.qml"));
+    view->setResizeMode(QQuickView::SizeRootObjectToView);
+
+#if defined(QML_MEDIA_PLAYER_DESKTOP_BUILD)
+    QScreen *desktop = QGuiApplication::primaryScreen();
+    if (desktop->physicalSize().height() < 1000) {
+        win.scale(.8, .8);
+        win.resize(win.size() * .8);
+    }
+    view->show();
+#else
+    view->showFullScreen();
+#endif
+
+    return application->exec();
+}

pool/shard006/C++/0078497_multisiginputentry.cpp

@@ -0,0 +1,174 @@
+#include <QApplication>
+#include <QClipboard>
+#include <string>
+#include <vector>
+
+#include "base58.h"
+#include "multisiginputentry.h"
+#include "ui_multisiginputentry.h"
+#include "main.h"
+#include "script.h"
+#include "util.h"
+#include "wallet.h"
+#include "walletmodel.h"
+
+
+MultisigInputEntry::MultisigInputEntry(QWidget *parent) : QFrame(parent), ui(new Ui::MultisigInputEntry), model(0)
+{
+    ui->setupUi(this);
+}
+
+MultisigInputEntry::~MultisigInputEntry()
+{
+    delete ui;
+}
+
+void MultisigInputEntry::setModel(WalletModel *model)
+{
+    this->model = model;
+    clear();
+}
+
+void MultisigInputEntry::clear()
+{
+    ui->transactionId->clear();
+    ui->transactionOutput->clear();
+    ui->redeemScript->clear();
+}
+
+bool MultisigInputEntry::validate()
+{
+    return (ui->transactionOutput->count() > 0);
+}
+
+CTxIn MultisigInputEntry::getInput()
+{
+    unsigned int nOutput = ui->transactionOutput->currentIndex();
+    CTxIn input(COutPoint(txHash, nOutput));
+
+    return input;
+}
+
+int64_t MultisigInputEntry::getAmount()
+{
+    int64_t amount = 0;
+    unsigned int nOutput = ui->transactionOutput->currentIndex();
+    CTransaction tx;
+    uint256 blockHash = 0;
+
+    if(GetTransaction(txHash, tx, blockHash))
+    {
+        if(nOutput < tx.vout.size())
+        {
+            const CTxOut& txOut = tx.vout[nOutput];
+            amount = txOut.nValue;
+        }
+    }
+
+    return amount;
+}
+
+QString MultisigInputEntry::getRedeemScript()
+{
+    return ui->redeemScript->text();
+}
+
+void MultisigInputEntry::setTransactionId(QString transactionId)
+{
+    ui->transactionId->setText(transactionId);
+}
+
+void MultisigInputEntry::setTransactionOutputIndex(int index)
+{
+    ui->transactionOutput->setCurrentIndex(index);
+}
+
+void MultisigInputEntry::setRemoveEnabled(bool enabled)
+{
+    ui->deleteButton->setEnabled(enabled);
+}
+
+void MultisigInputEntry::on_pasteTransactionIdButton_clicked()
+{
+    ui->transactionId->setText(QApplication::clipboard()->text());
+}
+
+void MultisigInputEntry::on_deleteButton_clicked()
+{
+    emit removeEntry(this);
+}
+
+void MultisigInputEntry::on_pasteRedeemScriptButton_clicked()
+{
+    ui->redeemScript->setText(QApplication::clipboard()->text());
+}
+
+void MultisigInputEntry::on_transactionId_textChanged(const QString &transactionId)
+{
+    ui->transactionOutput->clear();
+    if(transactionId.isEmpty())
+        return;
+
+    // Make list of transaction outputs
+    txHash.SetHex(transactionId.toStdString().c_str());
+    CTransaction tx;
+    uint256 blockHash = 0;
+    if(!GetTransaction(txHash, tx, blockHash))
+        return;
+    for(unsigned int i = 0; i < tx.vout.size(); i++)
+    {
+        QString idStr;
+        idStr.setNum(i);
+        const CTxOut& txOut = tx.vout[i];
+        int64_t amount = txOut.nValue;
+        QString amountStr;
+        amountStr.sprintf("%.6f", (double) amount / COIN);
+        CScript script = txOut.scriptPubKey;
+        CTxDestination addr;
+        if(ExtractDestination(script, addr))
+        {
+            CBitcoinAddress address(addr);
+            QString addressStr(address.ToString().c_str());
+            ui->transactionOutput->addItem(idStr + QString(" - ") + addressStr + QString(" - ") + amountStr + QString(" MSCN"));
+        }
+        else
+            ui->transactionOutput->addItem(idStr + QString(" - ") + amountStr + QString(" MSCN"));
+    }
+}
+
+void MultisigInputEntry::on_transactionOutput_currentIndexChanged(int index)
+{
+    if(ui->transactionOutput->itemText(index).isEmpty())
+        return;
+
+    CTransaction tx;
+    uint256 blockHash = 0;
+    if(!GetTransaction(txHash, tx, blockHash))
+        return;
+    const CTxOut& txOut = tx.vout[index];
+    CScript script = txOut.scriptPubKey;
+
+    if(script.IsPayToScriptHash())
+    {
+        ui->redeemScript->setEnabled(true);
+
+        if(model)
+        {
+             // Try to find the redeem script
+             CTxDestination dest;
+            if(ExtractDestination(script, dest))
+            {
+                CScriptID scriptID = boost::get<CScriptID>(dest);
+                CScript redeemScript;
+                if(model->getWallet()->GetCScript(scriptID, redeemScript))
+                    ui->redeemScript->setText(HexStr(redeemScript.begin(), redeemScript.end()).c_str());
+            }
+        }
+    }
+    else
+    {
+        ui->redeemScript->setEnabled(false);
+    }
+
+    emit updateAmount();
+}

pool/shard006/C++/0078507_JSCSSValueCustom.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2007, 2008 Apple 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 COMPUTER, INC. ``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 COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "JSCSSValue.h"
+
+#include "CSSPrimitiveValue.h"
+#include "CSSValueList.h"
+#include "JSCSSPrimitiveValue.h"
+#include "JSCSSValueList.h"
+#include "JSWebKitCSSTransformValue.h"
+#include "WebKitCSSTransformValue.h"
+
+#if ENABLE(SVG)
+#include "JSSVGColor.h"
+#include "JSSVGPaint.h"
+#include "SVGColor.h"
+#include "SVGPaint.h"
+#endif
+
+using namespace JSC;
+
+namespace WebCore {
+
+JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, CSSValue* value)
+{
+    if (!value)
+        return jsNull();
+
+    DOMObject* wrapper = getCachedDOMObjectWrapper(exec, value);
+
+    if (wrapper)
+        return wrapper;
+
+    if (value->isWebKitCSSTransformValue())
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, WebKitCSSTransformValue, value);
+    else if (value->isValueList())
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, CSSValueList, value);
+#if ENABLE(SVG)
+    else if (value->isSVGPaint())
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, SVGPaint, value);
+    else if (value->isSVGColor())
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, SVGColor, value);
+#endif
+    else if (value->isPrimitiveValue())
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, CSSPrimitiveValue, value);
+    else
+        wrapper = CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, CSSValue, value);
+
+    return wrapper;
+}
+
+} // namespace WebCore

pool/shard006/C++/0078514_jdtrans.cpp

@@ -0,0 +1,125 @@
+/*
+ * jdtrans.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL void transdecode_master_selection JPP( (j_decompress_ptr cinfo) );
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component.  The return value is a pointer to the array of
+ * virtual-array descriptors.  These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * Returns NULL if suspended.  This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL jvirt_barray_ptr *
+jpeg_read_coefficients( j_decompress_ptr cinfo ) {
+    if ( cinfo->global_state == DSTATE_READY ) {
+        /* First call: initialize active modules */
+        transdecode_master_selection( cinfo );
+        cinfo->global_state = DSTATE_RDCOEFS;
+    } else if ( cinfo->global_state != DSTATE_RDCOEFS ) {
+        ERREXIT1( cinfo, JERR_BAD_STATE, cinfo->global_state );
+    }
+    /* Absorb whole file into the coef buffer */
+    for (;; ) {
+        int retcode;
+        /* Call progress monitor hook if present */
+        if ( cinfo->progress != NULL ) {
+            ( *cinfo->progress->progress_monitor )( (j_common_ptr) cinfo );
+        }
+        /* Absorb some more input */
+        retcode = ( *cinfo->inputctl->consume_input )( cinfo );
+        if ( retcode == JPEG_SUSPENDED ) {
+            return NULL;
+        }
+        if ( retcode == JPEG_REACHED_EOI ) {
+            break;
+        }
+        /* Advance progress counter if appropriate */
+        if ( ( cinfo->progress != NULL ) &&
+            ( ( retcode == JPEG_ROW_COMPLETED ) || ( retcode == JPEG_REACHED_SOS ) ) ) {
+            if ( ++cinfo->progress->pass_counter >= cinfo->progress->pass_limit ) {
+                /* startup underestimated number of scans; ratchet up one scan */
+                cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+            }
+        }
+    }
+    /* Set state so that jpeg_finish_decompress does the right thing */
+    cinfo->global_state = DSTATE_STOPPING;
+    return cinfo->coef->coef_arrays;
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL void
+transdecode_master_selection( j_decompress_ptr cinfo ) {
+    /* Entropy decoding: either Huffman or arithmetic coding. */
+    if ( cinfo->arith_code ) {
+        ERREXIT( cinfo, JERR_ARITH_NOTIMPL );
+    } else {
+        if ( cinfo->progressive_mode ) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+            jinit_phuff_decoder( cinfo );
+#else
+            ERREXIT( cinfo, JERR_NOT_COMPILED );
+#endif
+        } else {
+            jinit_huff_decoder( cinfo );
+        }
+    }
+
+    /* Always get a full-image coefficient buffer. */
+    jinit_d_coef_controller( cinfo, TRUE );
+
+    /* We can now tell the memory manager to allocate virtual arrays. */
+    ( *cinfo->mem->realize_virt_arrays )( (j_common_ptr) cinfo );
+
+    /* Initialize input side of decompressor to consume first scan. */
+    ( *cinfo->inputctl->start_input_pass )( cinfo );
+
+    /* Initialize progress monitoring. */
+    if ( cinfo->progress != NULL ) {
+        int nscans;
+        /* Estimate number of scans to set pass_limit. */
+        if ( cinfo->progressive_mode ) {
+            /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+            nscans = 2 + 3 * cinfo->num_components;
+        } else if ( cinfo->inputctl->has_multiple_scans ) {
+            /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+            nscans = cinfo->num_components;
+        } else {
+            nscans = 1;
+        }
+        cinfo->progress->pass_counter = 0L;
+        cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+        cinfo->progress->completed_passes = 0;
+        cinfo->progress->total_passes = 1;
+    }
+}

pool/shard006/C++/0078515_boss_SpoilsOfPandaria.cpp

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2013-2015 DeathCore <http://www.noffearrdeathproject.net/>
+ * 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/>.
+ */
+
+#include "ScriptMgr.h"
+#include "ScriptedCreature.h"
+#include "SiegeOfOrgrimmar.h"
+
+enum Texts
+{
+    SAY_AGGRO       = 0,
+    SAY_EARTHQUAKE  = 1,
+    SAY_OVERRUN     = 2,
+    SAY_SLAY        = 3,
+    SAY_DEATH       = 4
+};
+
+enum Spells
+{
+    SPELL_EARTHQUAKE        = 153616,
+    SPELL_SUNDER_ARMOR      = 153726,
+    SPELL_CHAIN_LIGHTNING   = 153764,
+    SPELL_OVERRUN           = 154221,
+    SPELL_ENRAGE            = 157173,
+    SPELL_MARK_DEATH        = 153234,
+    SPELL_AURA_DEATH        = 153616
+};
+
+enum Events
+{
+    EVENT_ENRAGE    = 1,
+    EVENT_ARMOR     = 2,
+    EVENT_CHAIN     = 3,
+    EVENT_QUAKE     = 4,
+    EVENT_OVERRUN   = 5
+};
+
+class boss_SpoilsOfPandaria : public CreatureScript
+{
+    public:
+        boss_SpoilsOfPandaria() : CreatureScript("boss_SpoilsOfPandaria") { }
+
+        struct boss_SpoilsOfPandariaAI : public ScriptedAI
+        {
+            boss_SpoilsOfPandariaAI(Creature* creature) : ScriptedAI(creature)
+            {
+                Initialize();
+            }
+
+            void Initialize()
+            {
+                _inEnrage = false;
+            }
+
+            void Reset() override
+            {
+                _events.Reset();
+                _events.ScheduleEvent(EVENT_ENRAGE, 0);
+                _events.ScheduleEvent(EVENT_ARMOR, urand(5000, 13000));
+                _events.ScheduleEvent(EVENT_CHAIN, urand(10000, 30000));
+                _events.ScheduleEvent(EVENT_QUAKE, urand(25000, 35000));
+                _events.ScheduleEvent(EVENT_OVERRUN, urand(30000, 45000));
+                Initialize();
+            }
+
+            void KilledUnit(Unit* victim) override
+            {
+                victim->CastSpell(victim, SPELL_MARK_DEATH, 0);
+
+                if (urand(0, 4))
+                    return;
+
+                Talk(SAY_SLAY);
+            }
+
+            void JustDied(Unit* /*killer*/) override
+            {
+                Talk(SAY_DEATH);
+            }
+
+            void EnterCombat(Unit* /*who*/) override
+            {
+                Talk(SAY_AGGRO);
+            }
+
+            void MoveInLineOfSight(Unit* who) override
+
+            {
+                if (who && who->GetTypeId() == TYPEID_PLAYER && me->IsValidAttackTarget(who))
+                    if (who->HasAura(SPELL_MARK_DEATH))
+                        who->CastSpell(who, SPELL_AURA_DEATH, 1);
+            }
+
+            void UpdateAI(uint32 diff) override
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _events.Update(diff);
+
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
+
+                while (uint32 eventId = _events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_ENRAGE:
+                            if (!HealthAbovePct(20))
+                            {
+                                DoCast(me, SPELL_ENRAGE);
+                                _events.ScheduleEvent(EVENT_ENRAGE, 6000);
+                                _inEnrage = true;
+                            }
+                            break;
+                        case EVENT_OVERRUN:
+                            Talk(SAY_OVERRUN);
+                            DoCastVictim(SPELL_OVERRUN);
+                            _events.ScheduleEvent(EVENT_OVERRUN, urand(25000, 40000));
+                            break;
+                        case EVENT_QUAKE:
+                            if (urand(0, 1))
+                                return;
+
+                            Talk(SAY_EARTHQUAKE);
+
+                            //remove enrage before casting earthquake because enrage + earthquake = 16000dmg over 8sec and all dead
+                            if (_inEnrage)
+                                me->RemoveAurasDueToSpell(SPELL_ENRAGE);
+
+                            DoCast(me, SPELL_EARTHQUAKE);
+                            _events.ScheduleEvent(EVENT_QUAKE, urand(30000, 55000));
+                            break;
+                        case EVENT_CHAIN:
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
+                                DoCast(target, SPELL_CHAIN_LIGHTNING);
+                            _events.ScheduleEvent(EVENT_CHAIN, urand(7000, 27000));
+                            break;
+                        case EVENT_ARMOR:
+                            DoCastVictim(SPELL_SUNDER_ARMOR);
+                            _events.ScheduleEvent(EVENT_ARMOR, urand(10000, 25000));
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                DoMeleeAttackIfReady();
+            }
+
+            private:
+                EventMap _events;
+                bool _inEnrage;
+        };
+
+        CreatureAI* GetAI(Creature* creature) const override
+        {
+            return new boss_SpoilsOfPandariaAI(creature);
+        }
+};
+
+void AddSC_boss_SpoilsOfPandaria()
+{
+    new boss_SpoilsOfPandaria();
+}

pool/shard006/C++/0078516_RGBLed.cpp

@@ -0,0 +1,55 @@
+#include "RGBLed.h"
+/**
+ * RGBLed
+ * Default constructor, init class value and set com PIN to 8,9,10
+ */
+
+RGBLed :: RGBLed()
+{
+    redPin = 6;
+    greenPin = 9;
+    bluePin = 8;
+
+}
+
+/**
+ * RGBLed
+ * Overrided constructor, init set com PIN with param
+ * @param _redPin
+ * @param _greenPin
+ * @param _bluePin
+ */
+
+RGBLed :: RGBLed(int _redPin,int _greenPin,int _bluePin)
+{
+    redPin = _redPin;
+    greenPin = _greenPin;
+    bluePin = _bluePin;
+}
+
+/**
+ * lightOn
+ * set color value green, blue, red
+ * @param red
+ * @param green
+ * @param blue
+ */
+void RGBLed :: lightOn(int red,int green,int blue)
+{
+    analogWrite(redPin, red);
+    analogWrite(greenPin, green);
+    analogWrite(bluePin, blue);
+}
+
+/**
+ * lightOff
+ * switchOff RGB Led
+ */
+void RGBLed :: lightOff()
+{
+    analogWrite(redPin, 0);
+    analogWrite(greenPin, 0);
+    analogWrite(bluePin, 0);
+}
+
+

pool/shard006/C++/0078519_iniparser.cpp

@@ -0,0 +1,165 @@
+/**
+ *  This file is a part of ncxmms2, an XMMS2 Client.
+ *
+ *  Copyright (C) 2011-2015 Pavel Kunavin <tusk.kun@gmail.com>
+ *
+ *  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.
+ */
+
+#include <glib.h>
+#include "iniparser.h"
+
+namespace ncxmms2 {
+
+class IniParserPrivate
+{
+public:
+    IniParserPrivate() :
+        keyFile(nullptr) {}
+
+    std::string errorString;
+    std::string filePath;
+    GKeyFile *keyFile;
+
+    void closeFile();
+};
+} // ncxmms2
+
+using namespace ncxmms2;
+
+void IniParserPrivate::closeFile()
+{
+    errorString.clear();
+    if (keyFile) {
+        g_key_file_free(keyFile);
+        keyFile = nullptr;
+    }
+}
+
+IniParser::IniParser() :
+    d(new IniParserPrivate())
+{
+
+}
+
+IniParser::~IniParser()
+{
+    sync();
+    d->closeFile();
+}
+
+void IniParser::setFile(const std::string& file)
+{
+    sync();
+    d->closeFile();
+
+    d->filePath = file;
+    d->keyFile = g_key_file_new();
+    GError *error = nullptr;
+    if (!g_key_file_load_from_file(d->keyFile, d->filePath.c_str(),
+                                   G_KEY_FILE_KEEP_COMMENTS, &error)) {
+        d->errorString = error->message;
+        g_error_free(error);
+    }
+}
+
+void IniParser::sync()
+{
+    if (!d->keyFile)
+        return;
+
+    gsize size;
+    gchar *data = g_key_file_to_data(d->keyFile, &size, nullptr);
+
+    GError *error = nullptr;
+    g_file_set_contents(d->filePath.c_str(), data, size, &error);
+    if (error) {
+        d->errorString = error->message;
+        g_error_free(error);
+    }
+    g_free(data);
+}
+
+bool IniParser::isOk() const
+{
+    return d->errorString.empty();
+}
+
+std::string IniParser::errorString() const
+{
+    return d->errorString;
+}
+
+void IniParser::setValue(const std::string& group, const std::string& key, int value)
+{
+    if (!d->keyFile)
+        return;
+
+    g_key_file_set_integer(d->keyFile, group.c_str(), key.c_str(), value);
+}
+
+void IniParser::setValue(const std::string& group, const std::string& key, const std::string& value)
+{
+    if (!d->keyFile)
+        return;
+
+    g_key_file_set_string(d->keyFile, group.c_str(), key.c_str(), value.c_str());
+}
+
+void IniParser::setValue(const std::string& group, const std::string& key, bool value)
+{
+    if (!d->keyFile)
+        return;
+
+    g_key_file_set_boolean(d->keyFile, group.c_str(), key.c_str(), value);
+}
+
+void IniParser::getValue(const std::string& group, const std::string& key, int *value) const
+{
+    if (!d->keyFile)
+        return;
+
+    GError *error = nullptr;
+    int val = g_key_file_get_integer(d->keyFile, group.c_str(), key.c_str(), &error);
+    if (error) {
+        g_error_free(error);;
+    } else {
+        *value = val;
+    }
+}
+
+void IniParser::getValue(const std::string& group, const std::string& key, std::string *value) const
+{
+    if (!d->keyFile)
+        return;
+
+    gchar *string = g_key_file_get_string(d->keyFile, group.c_str(), key.c_str(), nullptr);
+    if (string) {
+        value->assign(string);
+        g_free(string);
+    }
+}
+
+void IniParser::getValue(const std::string& group, const std::string& key, bool *value) const
+{
+    if (!d->keyFile)
+        return;
+
+    GError *error = nullptr;
+    gboolean val = g_key_file_get_boolean(d->keyFile, group.c_str(), key.c_str(), &error);
+    if (error) {
+        g_error_free(error);;
+    } else {
+        *value = val;
+    }
+}
+
+

pool/shard006/C++/0078520_06.cpp

@@ -0,0 +1,31 @@
+#include "bm_oopsla.h"
+
+int main(int argc, char * argv[]) {
+  RECORD(4, w, x, y, z);
+
+  w = 1;
+  z = 0;
+  x = 0;
+  y = 0;
+
+  while (unknown1()) {
+    PRINT_VARS();
+    PRINT_BAR(1);
+
+    while (unknown2()) {
+      PRINT_VARS();
+
+      if (w % 2 == 1) x++;
+      if (z % 2 == 0) y++;
+    }
+    PRINT_VARS();
+    PRINT_BAR(2);
+
+    z = x + y;
+    w = z + 1;
+  }
+  PRINT_VARS();
+  PRINT_BAR(1);
+
+  assert(x == y);
+}

pool/shard006/C++/0078524_FlightMapSettings.cc

@@ -0,0 +1,159 @@
+/*=====================================================================
+
+ QGroundControl Open Source Ground Control Station
+
+ (c) 2009 - 2015 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+
+ This file is part of the QGROUNDCONTROL project
+
+ QGROUNDCONTROL 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.
+
+ QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+
+ ======================================================================*/
+
+#include "FlightMapSettings.h"
+
+#include <QSettings>
+#include <QtQml>
+
+const char* FlightMapSettings::_defaultMapProvider =    "Bing";                 // Bing is default since it support full street/satellite/hybrid set
+const char* FlightMapSettings::_settingsGroup =         "FlightMapSettings";
+const char* FlightMapSettings::_mapProviderKey =        "MapProvider";
+const char* FlightMapSettings::_mapTypeKey =            "MapType";
+
+FlightMapSettings::FlightMapSettings(QGCApplication* app)
+    : QGCTool(app)
+    , _mapProvider(_defaultMapProvider)
+{
+}
+
+void FlightMapSettings::setToolbox(QGCToolbox *toolbox)
+{
+    QGCTool::setToolbox(toolbox);
+
+    qmlRegisterUncreatableType<FlightMapSettings> ("QGroundControl", 1, 0, "FlightMapSetting", "Reference only");
+
+    _supportedMapProviders << "Bing" << "Google"; // << "OpenStreetMap";
+
+    _loadSettings();
+}
+
+void FlightMapSettings::_storeSettings(void)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.setValue(_mapProviderKey, _supportedMapProviders.contains(_mapProvider) ? _mapProvider : _defaultMapProvider);
+}
+
+void FlightMapSettings::_loadSettings(void)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    _mapProvider = settings.value(_mapProviderKey, _defaultMapProvider).toString();
+
+    if (!_supportedMapProviders.contains(_mapProvider)) {
+        _mapProvider = _defaultMapProvider;
+    }
+
+    _setMapTypesForCurrentProvider();
+}
+
+QString FlightMapSettings::mapProvider(void)
+{
+    return _mapProvider;
+}
+
+void FlightMapSettings::setMapProvider(const QString& mapProvider)
+{
+    if (_supportedMapProviders.contains(mapProvider)) {
+        _mapProvider = mapProvider;
+        _storeSettings();
+        _setMapTypesForCurrentProvider();
+        emit mapProviderChanged(mapProvider);
+    }
+}
+
+void FlightMapSettings::_setMapTypesForCurrentProvider(void)
+{
+    _mapTypes.clear();
+
+    if (_mapProvider == "Bing") {
+        _mapTypes << "Street Map" << "Satellite Map" << "Hybrid Map";
+    } else if (_mapProvider == "Google") {
+        _mapTypes << "Street Map" << "Satellite Map" << "Terrain Map";
+    /*
+    } else if (_mapProvider == "OpenStreetMap") {
+        _mapTypes << "Street Map";
+    */
+    }
+
+    emit mapTypesChanged(_mapTypes);
+}
+
+QString FlightMapSettings::mapTypeForMapName(const QString& mapName)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    settings.beginGroup(_mapProvider);
+    return settings.value(_mapTypeKey, "Satellite Map").toString();
+}
+
+void FlightMapSettings::setMapTypeForMapName(const QString& mapName, const QString& mapType)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    settings.beginGroup(_mapProvider);
+    settings.setValue(_mapTypeKey, mapType);
+}
+
+void FlightMapSettings::saveMapSetting (const QString &mapName, const QString& key, const QString& value)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    settings.setValue(key, value);
+}
+
+QString FlightMapSettings::loadMapSetting (const QString &mapName, const QString& key, const QString& defaultValue)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    return settings.value(key, defaultValue).toString();
+}
+
+void FlightMapSettings::saveBoolMapSetting (const QString &mapName, const QString& key, bool value)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    settings.setValue(key, value);
+}
+
+bool FlightMapSettings::loadBoolMapSetting (const QString &mapName, const QString& key, bool defaultValue)
+{
+    QSettings settings;
+
+    settings.beginGroup(_settingsGroup);
+    settings.beginGroup(mapName);
+    return settings.value(key, defaultValue).toBool();
+}

pool/shard006/C++/0078526_12665_jokingfermat.cpp

@@ -0,0 +1,92 @@
+#include <cstdio>
+#include <iostream>
+#include <vector>
+#include <cstring>
+#include <cstdlib>
+#include <cmath>
+#include <algorithm>
+
+using namespace std;
+
+//#define DEBUG  //comment this line to pull out print statements
+#ifdef DEBUG
+#define TAB '\t'
+#define debug(a, end) cout << #a << ": " << a << end
+#define dbg(end) end
+#else
+#define debug(a, end)
+#define dbg(end)
+#endif
+
+typedef pair<int, int> point;
+typedef vector<int> vi;
+typedef vector<point> vp;
+
+#define UN(v) SORT(v),v.erase(unique(v.begin(),v.end()),v.end())   
+#define SORT(c) sort((c).begin(),(c).end())   
+#define FOR(i,a,b) for (int  i=(a); i < (b); i++)    
+#define REP(i,n) FOR(i,0,(int)n)    
+#define CL(a,b) memset(a,b,sizeof(a))
+#define CL2d(a,b,x,y) memset(a, b, sizeof(a[0][0])*x*y)
+
+/*global variables*/
+int cubes[1001];
+int x, y;
+/*global variables*/
+
+void dump()
+{
+    //dump data
+}
+
+bool getInput()
+{
+    //get input
+    if (feof(stdin)) return false;
+    scanf("%d %d ", &x, &y);
+    return true;
+}
+
+void process()
+{
+    //process input
+    int n = 0;
+    long long c;
+    int b, e;
+    for (int a = x; a <= y; a++)
+    {
+        for (b = a+1; b <= 1001; b++)
+        {
+            c = cubes[a] + cubes[b];
+            e = c%10;
+            c /= 10;
+            if (c > y)
+                break;
+            if (e == 3)
+                n++;
+        }
+        if (b == (a+1)) break;
+    }
+    printf("%d\n", n*2);
+}
+
+int main()
+{
+    FOR(i, 1, 1001)
+    {
+        cubes[i] = pow(i, 3);
+    }
+    debug(sizeof(cubes[1000]), endl);
+    int pn = 1;
+    while (getInput())
+    {
+        printf("Case %d: ", pn++);
+        process();
+
+        /*CLEAR GLOBAL VARIABLES!*/
+
+        /*CLEAR GLOBAL VARIABLES!*/
+    }
+
+    return 0;
+}

pool/shard006/C++/0078527_InputManager.cpp

@@ -0,0 +1,63 @@
+#include "../include/InputManager.h"
+
+namespace FGF
+{
+	InputManager::InputManager()
+	{
+	}
+
+	InputManager::~InputManager()
+	{
+		key_press.clear();
+	}
+
+	bool InputManager::getKeyState(SDLKey key)
+	{
+		return SDL_GetKeyState(NULL)[key];
+	}
+
+	int InputManager::getMouseX()
+	{
+		int x;
+		SDL_GetMouseState(&x,NULL);
+		return x;
+	}
+	int InputManager::getMouseY()
+	{
+		int y;
+		SDL_GetMouseState(NULL,&y);
+		return y;
+	}
+
+	int InputManager::getMouseXRel()
+	{
+		int x;
+		SDL_GetRelativeMouseState(&x,NULL);
+		return x;
+	}
+	int InputManager::getMouseYRel()
+	{
+		int y;
+		SDL_GetRelativeMouseState(NULL,&y);
+		return y;
+	}
+
+	bool InputManager::getMouseButtonState(int button)
+	{
+		return (SDL_GetMouseState(NULL,NULL)&SDL_BUTTON(button));
+	}
+
+	void InputManager::setCommand_OnKeyPress(SDLKey key,ICommand* cmd)
+	{
+		key_press[key] = cmd;
+	}
+
+	void InputManager::Update(float dt)
+	{
+		for(std::map<SDLKey,ICommand*>::iterator it = key_press.begin();
+				it != key_press.end(); it++)
+		{
+			if(getKeyState(it->first)) it->second->Execute(dt);
+		}
+	}
+}

pool/shard006/C++/0078541_BroadcastDiscovery.cpp

@@ -0,0 +1,151 @@
+#include "umundo/discovery/BroadcastDiscovery.h"
+
+namespace umundo {
+
+/**
+ * Have a look at https://github.com/zeromq/czmq/blob/master/src/zbeacon.c#L81 to
+ * see how to setup UDP sockets for broadcast.
+ *
+ * Receiving Broadcast messages: https://github.com/zeromq/czmq/blob/master/src/zbeacon.c#L700
+ * Sending Broadcast messages: https://github.com/zeromq/czmq/blob/master/src/zbeacon.c#L751
+ */
+
+#if 0
+SOCKET BroadcastDiscovery::udpSocket = 0;
+RMutex BroadcastDiscovery::globalMutex;
+
+sockaddr_in BroadcastDiscovery::bCastAddress;
+char BroadcastDiscovery::hostName[NI_MAXHOST];
+#endif
+
+BroadcastDiscovery::BroadcastDiscovery() {
+	/**
+	 * This is called twice overall, once for the prototype in the factory and
+	 * once for the instance that is actually used.
+	 */
+}
+
+BroadcastDiscovery::~BroadcastDiscovery() {
+}
+
+#if 0
+void BroadcastDiscovery::setupUDPSocket() {
+	RScopeLock(globalMutex);
+	if (udpSocket == 0) {
+		int enable = 1;
+
+		udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+		if (udpSocket == INVALID_SOCKET)
+			return;
+
+		if (setsockopt (udpSocket, SOL_SOCKET, SO_BROADCAST, (char*)&enable, sizeof(enable)) == SOCKET_ERROR) {
+			//error
+		}
+		if (setsockopt (udpSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&enable, sizeof(enable)) == SOCKET_ERROR) {
+			//error
+		}
+
+#if defined (SO_REUSEPORT)
+		if (setsockopt (udpSocket, SOL_SOCKET, SO_REUSEPORT, (char*)&enable, sizeof(enable)) == SOCKET_ERROR) {
+			//error
+		}
+#endif
+		in_addr_t bindTo = INADDR_ANY;
+		in_addr_t sendTo = INADDR_BROADCAST;
+
+		bCastAddress.sin_family = AF_INET;
+		bCastAddress.sin_port = htons(43005);
+		bCastAddress.sin_addr.s_addr = sendTo;
+
+		sockaddr_in address = bCastAddress;
+		address.sin_addr.s_addr = bindTo;
+
+#if (defined (__WINDOWS__))
+		sockaddr_in sockaddr = address;
+#elif (defined (__APPLE__))
+		sockaddr_in sockaddr = bCastAddress;
+		sockaddr.sin_addr.s_addr = htons (INADDR_ANY);
+#else
+		sockaddr_in sockaddr = bCastAddress;
+#endif
+
+		if (bind (udpSocket, (struct sockaddr *) &sockaddr, sizeof (sockaddr_in))) {
+			// error
+		}
+
+		getnameinfo ((struct sockaddr *) &address, sizeof (sockaddr_in), hostName, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+
+	}
+}
+#endif
+
+SharedPtr<BroadcastDiscovery> BroadcastDiscovery::getInstance() {
+	if (_instance.get() == NULL) {
+		// setup UDP socket when th first instance is required
+		//setupUDPSocket();
+
+		_instance = SharedPtr<BroadcastDiscovery>(new BroadcastDiscovery());
+		_instance->start();
+	}
+	return _instance;
+}
+SharedPtr<BroadcastDiscovery> BroadcastDiscovery::_instance;
+
+SharedPtr<Implementation> BroadcastDiscovery::create() {
+	return getInstance();
+}
+
+void BroadcastDiscovery::init(const Options*) {
+	/*
+	 * This is where you can setup the non-prototype instance, i.e. not the one
+	 * in the factory, but the one created from the prototype.
+	 *
+	 * The options object is not used and empty.
+	 */
+}
+
+void BroadcastDiscovery::suspend() {
+}
+
+void BroadcastDiscovery::resume() {
+}
+
+void BroadcastDiscovery::advertise(const EndPoint& node) {
+	/**
+	 * umundo.core asks you to make the given node discoverable
+	 */
+}
+
+void BroadcastDiscovery::add(Node& node) {
+}
+
+void BroadcastDiscovery::unadvertise(const EndPoint& node) {
+	/**
+	 * umundo.core asks you to announce the removal of the given node
+	 */
+}
+
+void BroadcastDiscovery::remove(Node& node) {
+}
+
+void BroadcastDiscovery::browse(ResultSet<ENDPOINT_RS_TYPE>* query) {
+	/**
+	 * Another node wants to browse for nodes
+	 */
+}
+
+void BroadcastDiscovery::unbrowse(ResultSet<ENDPOINT_RS_TYPE>* query) {
+	/**
+	 * Another node no longer wants to browse for nodes
+	 */
+}
+
+std::vector<EndPoint> BroadcastDiscovery::list() {
+	return std::vector<EndPoint>();
+}
+
+void BroadcastDiscovery::run() {
+	// your very own thread!
+}
+
+}

pool/shard006/C++/0078543_string.cpp

@@ -0,0 +1,71 @@
+/*
+ * This file is a part of Luminance HDR package.
+ * ----------------------------------------------------------------------
+ * Copyright (C) 2013 Davide Anastasia
+ *
+ *  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 <Libpfs/utils/string.h>
+
+#include <cmath>
+#include <algorithm>
+
+using namespace std;
+
+namespace pfs {
+namespace utils {
+
+// Utility functions for case insensitive string compare
+static
+int charDiff(char c1, char c2)
+{
+    if ( tolower(c1) < tolower(c2) ) return -1;
+    if ( tolower(c1) == tolower(c2) ) return 0;
+    return 1;
+}
+
+static
+int stringCompare(const string& str1, const string& str2)
+{
+    int diff = 0;
+    size_t size = std::min(str1.size(), str2.size());
+    for (size_t idx = 0; idx < size && diff == 0; ++idx)
+    {
+        diff = charDiff(str1[idx], str2[idx]);
+    }
+    if ( diff != 0 ) return diff;
+
+    if ( str2.length() == str1.length() ) return 0;
+    if ( str2.length() > str1.length() ) return 1;
+    return -1;
+}
+
+bool StringUnsensitiveComp::operator()(const std::string& str1, const std::string& str2) const {
+    return ( stringCompare(str1, str2) == -1 );
+}
+
+string getFormat(const string &filename)
+{
+    size_t i = filename.rfind('.', filename.length());
+    if ( i != string::npos ) {
+        return filename.substr(i+1, filename.length()-i);
+    }
+    return string();
+}
+
+}   // utils
+}   // pfs

pool/shard006/C++/0078550_remove_element.cpp

@@ -0,0 +1,76 @@
+/*
+ Remove Element
+
+ Given an array and a value, remove all instances of that value
+ in place and return the new length.
+
+ The order of elements can be changed.
+ It doesn't matter what you leave beyond the new length.
+
+ */
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int removeElement(int A[], int n, int elem)
+    {
+        if (n <= 0)
+            return n; //
+
+        if (n == 1)
+            return A[0] == elem ? 0 : 1;
+
+        int start = 0, end = n - 1;
+        while (start < end) {
+            if (A[start] != elem) {
+                start++;
+            } else if (A[end] == elem) {
+                end--;
+            } else {
+                swap(A[start], A[end]);
+                start++;
+                end--;
+            }
+        }
+        return start + (A[start] == elem ? 0 : 1); //
+    }
+
+    int removeElement2(int A[], int n, int elem)
+    {
+        int i = 0, j = 0;
+        while (j < n) {
+            if (A[j] != elem) A[i++] = A[j];
+            j++;
+        }
+        return i;
+    }
+
+    int removeElement3(int A[], int n, int elem)
+    {
+        int idx = 0;
+
+        for (int i = 0; i < n; i++) {
+            if (A[i] != elem) A[idx++] = A[i];
+        }
+
+        return idx;
+    }
+};
+
+int main(int argc, char *argv[])
+{
+    int a[] = { 3, 3, 5, 4, 5 };
+    Solution sol;
+
+    cout << sol.removeElement(a, sizeof(a) / sizeof(int), 5) << endl;
+
+    for (auto t : a)
+        cout << t << ends;
+
+    return 0;
+}

pool/shard006/C++/0078551_5.cpp

@@ -0,0 +1,108 @@
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        sort(nums.begin(), nums.end());
+        return nums[nums.size() - k ];
+    }
+}; 
+
+
+// n logn 
+// 
+
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        priority_queue<int> pq(nums.begin(), nums.end());
+        for (int i = 0; i < k - 1; i++)
+            pq.pop(); 
+        return pq.top();
+    }
+}; 
+
+//
+//
+class Solution {
+public:   
+    inline int left(int idx) {
+        return (idx << 1) + 1;
+    }
+    inline int right(int idx) {
+        return (idx << 1) + 2;
+    }
+    void max_heapify(vector<int>& nums, int idx) {
+        int largest = idx;
+        int l = left(idx), r = right(idx);
+        if (l < heap_size && nums[l] > nums[largest]) largest = l;
+        if (r < heap_size && nums[r] > nums[largest]) largest = r;
+        if (largest != idx) {
+            swap(nums[idx], nums[largest]);
+            max_heapify(nums, largest);
+        }
+    }
+    void build_max_heap(vector<int>& nums) {
+        heap_size = nums.size();
+        for (int i = (heap_size >> 1) - 1; i >= 0; i--)
+            max_heapify(nums, i);
+    }
+    int findKthLargest(vector<int>& nums, int k) {
+        build_max_heap(nums);
+        for (int i = 0; i < k; i++) {
+            swap(nums[0], nums[heap_size - 1]);
+            heap_size--;
+            max_heapify(nums, 0);
+        }
+        return nums[heap_size];
+    }
+private:
+    int heap_size;
+};
+
+//
+
+
+class Solution { 
+public:
+    inline int swap(vector<int>& nums, int left, int right){
+        if (left <0 or right>= nums.size()) return -1;
+        int temp = nums[left];
+        nums[left] = nums[right];
+        nums[right] = temp;
+
+        return 1;
+    }
+
+    int partition(vector<int>& nums, int left, int right) {
+        int pivot = nums[left];
+        int l = left + 1, r = right;
+        while (l <= r) {
+            if (nums[l] < pivot && nums[r] > pivot)
+                swap(nums,l++, r--);
+
+            if (nums[l] >= pivot) l++; 
+            if (nums[r] <= pivot) r--;
+        }
+        swap(nums,left, r);
+        return r;
+    }
+
+    /*
+     * param k : description of k
+     * param nums : description of array and index 0 ~ n-1
+     * return: description of return
+     */
+    
+    int findKthLargest(vector<int>& nums, int k) {
+        int left = 0, right = nums.size() - 1;
+        while (true) {
+            int pos = partition(nums, left, right);
+            if (pos == k - 1) return nums[pos];
+            if (pos > k - 1) right = pos - 1;
+            else left = pos + 1;
+        }
+
+        
+    }
+};

pool/shard006/C++/0078556_uri.cpp

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the gecko project.
+
+#include <base/ansi.h>
+#include <base/contract.h>
+#include <base/string_util.h>
+#include <base/unit_test.h>
+#include <base/uri.h>
+#include <iostream>
+#include <sstream>
+
+namespace
+{
+void check(
+    base::unit_test &  ut,
+    const std::string &test,
+    bool               should = true,
+    bool               except = false )
+{
+    try
+    {
+        base::uri   u( test );
+        std::string match = base::to_string( u );
+
+        if ( test == match )
+            ut.success( test );
+        else if ( !should )
+            ut.negative_success( test + " != " + match );
+        else
+            ut.failure( test + " != " + match );
+    }
+    catch ( const std::exception &e )
+    {
+        std::stringstream msg;
+        base::print_exception( msg, e );
+        if ( except )
+            ut.negative_success( test + " -> exception " + msg.str() );
+        else
+            ut.failure( test + " -> exception " + msg.str() );
+    }
+}
+
+int safemain( int argc, char *argv[] )
+{
+    base::unit_test test( "uri" );
+
+    base::cmd_line options( argv[0] );
+    test.setup( options );
+
+    try
+    {
+        options.parse( argc, argv );
+    }
+    catch ( ... )
+    {
+        throw_add( "parsing command line arguments" );
+    }
+
+    test["basic_parsing"] = [&]( void ) {
+        check( test, "http", false, true );
+        check( test, "http:", false, true );
+        check( test, "file:/tmp" );
+        check( test, "file:///tmp", false );
+        check( test, "http://host.com" );
+        check( test, "http://user@host.com" );
+        check( test, "http://host.com:1234" );
+        check( test, "http://user@host.com:1234" );
+        check( test, "http://host.com/path1" );
+        check( test, "http://host.com/path1/path2" );
+    };
+
+    test["parse_query_frag"] = [&]( void ) {
+        check( test, "http://host.com?query" );
+        check( test, "http://host.com#frag" );
+        check( test, "http://host.com?query#frag" );
+        check( test, "http://host.com/path1?query#frag" );
+    };
+
+    test["parse_encoded"] = [&]( void ) {
+        check( test, "http://host.com/path1#frag%3Fmorefrag" );
+        check( test, "http://host%2ecom", false );
+        check( test, "http://host%2Ecom", false );
+        check( test, "http://host.com/%2fmore", false );
+        check( test, "http://host.com/%2Fmore" );
+        check( test, "http://host.com/with%20space", false );
+        check( test, "http://host.com/with space", true );
+    };
+
+    test["path_construction"] = [&]( void ) {
+        base::uri tf( "file", "" );
+        tf /= "file.txt";
+        if ( tf.pretty() == "file:///file.txt" )
+            test.success( "operator/=" );
+        else
+            test.failure( "operator/= -> {0}", tf );
+
+        tf = base::uri( "file", "" ) / "hello" / "world";
+        if ( tf.pretty() == "file:///hello/world" )
+            test.success( "operator/" );
+        else
+            test.failure( "operator/ -> {0}", tf );
+    };
+
+    //	test.cleanup() = [&]( void ) {};
+    test.run( options );
+    test.clean();
+
+    return -static_cast<int>( test.failure_count() );
+}
+
+} // namespace
+
+int main( int argc, char *argv[] )
+{
+    try
+    {
+        return safemain( argc, argv );
+    }
+    catch ( const std::exception &e )
+    {
+        base::print_exception( std::cerr, e );
+    }
+    return -1;
+}

pool/shard006/C++/0078558_partialdate.cpp

@@ -0,0 +1,217 @@
+/***************************************************************************
+ *   (C) 2005-2009 Michal Rudolf <mrudolf@kdewebdev.org>                   *
+ *                                                                         *
+ *   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.                                   *
+ ***************************************************************************/
+
+#include "partialdate.h"
+#include <QRegExp>
+
+PartialDate::PartialDate(int y, int m, int d) :
+    m_year(y),
+    m_month(m),
+    m_day(d)
+{
+    m_bIsValid = !m_year || asDate().isValid();
+}
+
+PartialDate::PartialDate(const QString& s)
+{
+    m_year = 0;
+    m_month = 0;
+    m_day = 0;
+    fromString(s);
+}
+
+PartialDate::PartialDate(const QDate& d)
+{
+    m_bIsValid = true;
+    m_year = d.year();
+    m_month = d.month();
+    m_day = d.day();
+}
+
+PartialDate PartialDate::today()
+{
+    return PartialDate(QDate::currentDate());
+}
+
+int PartialDate::year() const
+{
+    return m_year;
+}
+
+int PartialDate::month() const
+{
+    return m_month;
+}
+
+int PartialDate::day() const
+{
+    return m_day;
+}
+
+PartialDate& PartialDate::fromString(const QString& s)
+{
+    QString test = s.trimmed();
+    QRegExp regExp("^[\\?0-9]{4}([\\./]([\\?0-9]){1,2}){,2}$");
+    if(regExp.exactMatch(test) || test.isEmpty())
+    {
+        QRegExp sep("[\\./]");
+        m_year = test.section(sep, 0, 0).toInt();
+        m_month = test.section(sep, 1, 1).toInt();
+        m_day = test.section(sep, 2, 2).toInt();
+        m_bIsValid = !year() || asDate().isValid();
+    }
+    else
+    {
+        QRegExp regExpContinental("^(([\\?0-9]){1,2}\\.){,2}[\\?0-9]{4}$");
+        if(regExpContinental.exactMatch(test))
+        {
+            m_day = test.section('.', 0, 0).toInt();
+            m_month = test.section('.', 1, 1).toInt();
+            m_year = test.section('.', 2, 2).toInt();
+            m_bIsValid = !year() || asDate().isValid();
+        }
+        else
+        {
+            QRegExp regExpAmerican("^(([\\?0-9]){1,2}/){,2}[\\?0-9]{4}$");
+            if(regExpAmerican.exactMatch(test))
+            {
+                m_month = test.section('/', 0, 0).toInt();
+                m_day = test.section('/', 1, 1).toInt();
+                m_year = test.section('/', 2, 2).toInt();
+                m_bIsValid = !year() || asDate().isValid();
+            }
+        }
+    }
+    return *this;
+}
+
+
+QDate PartialDate::asDate() const
+{
+    return QDate(m_year, m_month ? m_month : 1, m_day ? m_day : 1);
+}
+
+bool PartialDate::isValid() const
+{
+    return m_bIsValid;
+}
+
+QString PartialDate::asString() const
+{
+    if(!m_year)
+    {
+        return "????.??.??";
+    }
+    QString s = QString("%1.%2.%3")
+            .arg(m_year, 4)
+            .arg(numberToString(m_month))
+            .arg(numberToString(m_day));
+    return s;
+}
+
+QString PartialDate::asShortString(int part) const
+{
+    if(!m_year)
+    {
+        return QString();
+    }
+    QString s;
+    if(part & Year)
+    {
+        s = numberToString(m_year);
+    }
+    if(!m_month)
+    {
+        return s;
+    }
+    if(part & Month)
+    {
+        if(!s.isEmpty())
+        {
+            s += '.';
+        }
+        s += numberToString(m_month);
+    }
+    if(!m_day)
+    {
+        return s;
+    }
+    if(part & Day)
+    {
+        if(!s.isEmpty())
+        {
+            s += '.';
+        }
+        s += numberToString(m_day);
+    }
+    return s;
+}
+
+QString PartialDate::numberToString(int d, QChar fill) const
+{
+    if(!d)
+    {
+        return "??";
+    }
+    return d < 10 ? QString(fill) + QString::number(d) : QString::number(d);
+}
+
+bool operator==(const PartialDate& d1, const PartialDate& d2)
+{
+    return d1.year() == d2.year() && d1.month() == d2.month() && d1.day() == d2.day();
+}
+
+bool operator<(const PartialDate& d1, const PartialDate& d2)
+{
+    return d2.year() > d1.year() ||
+           ((d2.year() == d1.year()) &&
+            (d2.month() > d1.month() || (d2.month() == d1.month() && d2.day() > d1.day())));
+}
+
+bool operator>(const PartialDate& d1, const PartialDate& d2)
+{
+    return d1.year() > d2.year() ||
+           ((d1.year() == d2.year()) &&
+            (d1.month() > d2.month() || (d1.month() == d2.month() && d1.day() > d2.day())));
+}
+
+bool operator>=(const PartialDate& d1, const PartialDate& d2)
+{
+    return d2 < d1 || d2 == d1;
+}
+
+bool operator<=(const PartialDate& d1, const PartialDate& d2)
+{
+    return d2 > d1 || d2 == d1;
+}
+
+bool operator!=(const PartialDate& d1, const PartialDate& d2)
+{
+    return d1.year() != d2.year() || d1.month() != d2.month() || d1.day() != d2.day();
+}
+
+QString PartialDate::range(const PartialDate& d) const
+{
+    if(year() != d.year())
+    {
+        return asShortString() + "-" + d.asShortString();
+    }
+    QString result = numberToString(year());
+    if(month() != d.month())
+        return QString("%1.%2-%3").arg(year()).arg(asShortString(Month | Day))
+               .arg(d.asShortString(Month | Day));
+    else if(day() != d.day())
+        return QString("%1.%2.%3-%4").arg(year()).arg(month())
+               .arg(asShortString(Day)).arg(d.asShortString(Day));
+    else
+    {
+        return asShortString();
+    }
+}
+

pool/shard006/C++/0078561_ChShaftsTorqueConverter.cpp

@@ -0,0 +1,221 @@
+//
+// PROJECT CHRONO - http://projectchrono.org
+//
+// Copyright (c) 2010, 2012 Alessandro Tasora
+// Copyright (c) 2013 Project Chrono
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be 
+// found in the LICENSE file at the top level of the distribution
+// and at http://projectchrono.org/license-chrono.txt.
+//
+
+
+#include "physics/ChShaftsTorqueConverter.h"
+#include "physics/ChSystem.h"
+#include "physics/ChShaft.h"
+
+#include "core/ChMemory.h" // must be last include (memory leak debugger). In .cpp only.
+
+namespace chrono
+{
+
+
+// Register into the object factory, to enable run-time
+// dynamic creation and persistence
+ChClassRegister<ChShaftsTorqueConverter> a_registration_ChShaftsTorqueConverter;
+
+
+
+//////////////////////////////////////
+//////////////////////////////////////
+
+
+ChShaftsTorqueConverter::ChShaftsTorqueConverter ()
+{
+	this->shaft1 = 0;
+	this->shaft2 = 0;
+	this->shaft_stator = 0;
+	this->torque_in= 0;
+	this->torque_out= 0;
+	this->K = ChSharedPtr<ChFunction> (new ChFunction_Const(0.9));
+	this->T = ChSharedPtr<ChFunction> (new ChFunction_Const(0.9));
+	this->state_warning_reverseflow = false;
+	this->state_warning_wrongimpellerdirection = false;
+
+	SetIdentifier(GetUniqueIntID()); // mark with unique ID
+}
+
+
+ChShaftsTorqueConverter::~ChShaftsTorqueConverter ()
+{
+	
+}
+
+void ChShaftsTorqueConverter::Copy(ChShaftsTorqueConverter* source)
+{
+		// copy the parent class data...
+	ChPhysicsItem::Copy(source);
+
+		// copy class data
+	shaft1 = 0;
+	shaft2 = 0;
+	shaft_stator = 0;
+
+	torque_in = source->torque_in;
+	torque_out = source->torque_out;
+
+	state_warning_reverseflow = source->state_warning_reverseflow;
+	state_warning_wrongimpellerdirection = source->state_warning_wrongimpellerdirection;
+
+	this->K = ChSharedPtr<ChFunction>(K->new_Duplicate()); // deep copy
+	this->T = ChSharedPtr<ChFunction>(T->new_Duplicate()); // deep copy
+}
+
+
+int ChShaftsTorqueConverter::Initialize(ChSharedPtr<ChShaft> mshaft1, ChSharedPtr<ChShaft> mshaft2, ChSharedPtr<ChShaft> mshaft_stator)
+{
+	ChShaft* mm1 = mshaft1.get_ptr();
+	ChShaft* mm2 = mshaft2.get_ptr();
+	ChShaft* mm_stator = mshaft_stator.get_ptr();
+	assert(mm1 && mm2 && mm_stator);
+	assert((mm1 != mm2) && (mm1 != mm_stator));
+	assert((mm1->GetSystem() == mm2->GetSystem()) && (mm1->GetSystem() == mm_stator->GetSystem()));
+
+	this->shaft1 = mm1;
+	this->shaft2 = mm2;
+	this->shaft_stator = mm_stator;
+
+	this->SetSystem(this->shaft1->GetSystem());
+
+	return true;
+}
+
+
+double ChShaftsTorqueConverter::GetSpeedRatio() const
+{
+	double wrel1 = this->shaft1->GetPos_dt() - this->shaft_stator->GetPos_dt();
+	double wrel2 = this->shaft2->GetPos_dt() - this->shaft_stator->GetPos_dt();
+
+	if ((fabs(wrel1) < 10e-9) || (fabs(wrel2) < 10e-9))
+		return 0;
+
+	return wrel2/wrel1;
+}
+
+
+void ChShaftsTorqueConverter::Update (double mytime)
+{
+		// Inherit time changes of parent class
+	ChPhysicsItem::Update(mytime);
+	
+		// update class data
+	
+	state_warning_wrongimpellerdirection= false;
+	state_warning_reverseflow = false;
+
+	// Compute actual speed ratio
+	double mR = this->GetSpeedRatio();
+
+	// The speed ratio must always be in the [0...1] range,
+	// anyway let's correct singular cases:
+
+		// - it should be inusual that speed ratio >1, say if the impeller 
+		//   outruns turbine (if there's a clutch lock-in, this should happen). 
+		//   If so, assume a reflection of T curve and a polar reflection of K curve, after 1. 
+	if (mR > 1)
+	{
+		mR = 1-(mR-1); 
+		state_warning_reverseflow = true;
+	}
+
+		// - if the output shaft is spinning a bit backward, when
+		//   close to stall, maybe win/wout < 0. If so, set as stall anyway:
+	if (mR < 0)
+		mR = 0; 
+
+		// - if input impeller shaft is spinning in negative direction,
+		//   this is assumed as an error: set all torques to zero and bail out:
+	if (this->shaft1->GetPos_dt() - this->shaft_stator->GetPos_dt() < 0)
+	{
+		state_warning_wrongimpellerdirection = true;
+		this->torque_in = 0;
+		this->torque_out = 0;
+		return;
+	}
+
+	// Compute actual capacity factor
+	double mK = K->Get_y(mR);
+
+	// Compute actual torque factor
+	double mT = T->Get_y(mR);
+
+	// compute input torque (with minus sign because applied TO input thaft)
+	this->torque_in = - pow(( this->shaft1->GetPos_dt() / mK ),2);
+
+	if (state_warning_reverseflow)
+		this->torque_in =  -this->torque_in;
+
+	// compute output torque (with opposite sign because 
+	// applied to output shaft, with same direction of input shaft)
+	this->torque_out = - mT * this->torque_in;
+}
+
+
+
+
+////////// LCP INTERFACES ////
+
+
+
+void ChShaftsTorqueConverter::VariablesFbLoadForces(double factor)
+{
+	// Apply torques to the three connected 1D variables:
+	shaft1->Variables().Get_fb().ElementN(0)	   +=  torque_in*factor;
+	shaft2->Variables().Get_fb().ElementN(0)	   +=  torque_out*factor;
+	shaft_stator->Variables().Get_fb().ElementN(0) +=  GetTorqueReactionOnStator()*factor;
+}
+
+
+
+//////// FILE I/O
+
+void ChShaftsTorqueConverter::StreamOUT(ChStreamOutBinary& mstream)
+{
+			// class version number
+	mstream.VersionWrite(1);
+
+		// serialize parent class too
+	ChPhysicsItem::StreamOUT(mstream);
+
+		// stream out all member data
+	mstream.AbstractWrite(this->K.get_ptr()); //***TODO*** proper serialize for ChSharedPtr
+	mstream.AbstractWrite(this->T.get_ptr()); //***TODO*** proper serialize for ChSharedPtr
+}
+
+void ChShaftsTorqueConverter::StreamIN(ChStreamInBinary& mstream)
+{
+		// class version number
+	int version = mstream.VersionRead();
+
+		// deserialize parent class too
+	ChPhysicsItem::StreamIN(mstream);
+
+		// deserialize class
+	ChFunction* newfun;
+	mstream.AbstractReadCreate(&newfun); //***TODO*** proper deserialize for ChSharedPtr
+	this->K = ChSharedPtr<ChFunction>(newfun);
+	mstream.AbstractReadCreate(&newfun); //***TODO*** proper deserialize for ChSharedPtr
+	this->T = ChSharedPtr<ChFunction>(newfun);;
+	
+}
+
+
+
+
+
+
+} // END_OF_NAMESPACE____
+
+
+/////////////////////

pool/shard006/C++/0078564_command_interface.cpp

@@ -0,0 +1,47 @@
+#include "command_interface.h"
+
+#include <vector>
+
+#include "abort/abort.h"
+#include "util/str_util.h"
+
+namespace Chess
+{
+    CommandInterface::CommandInterface()
+        : _cmd_map()
+    {
+    }
+
+    bool CommandInterface::install(const std::string& name,
+                                   handler_t handler)
+    {
+        const std::string cmdName = Util::trim(Util::to_lower(name));
+        AbortIf(cmdName.empty(), false);
+
+        _cmd_map[cmdName] = handler;
+        return true;
+    }
+
+    bool CommandInterface::process(const std::string& data)
+    {
+        const std::string input = Util::trim(data);
+        AbortIf(input.empty(), false);
+
+        std::vector<std::string> tokens;  Util::split(input, tokens);
+        AbortIf(tokens.empty(), false);
+
+        const std::string cmd = Util::to_lower( tokens[0] );
+        auto iter = _cmd_map.find(cmd);
+
+        AbortIf(iter == _cmd_map.end(), false);
+
+        tokens.erase(tokens.begin());
+
+        const std::string args = Util::build_string(tokens, " ");
+
+        // Invoke the handler for this command
+
+        iter->second(args);
+        return true;
+    }
+}

pool/shard006/C++/0078577_Led.cpp

@@ -0,0 +1,109 @@
+/*
+   To change this license header, choose License Headers in Project Properties.
+   To change this template file, choose Tools | Templates
+   and open the template in the editor.
+*/
+
+/*
+   File:   Led.cpp
+   Author: Mathilde
+
+   Created on 25 octobre 2016, 16:29
+*/
+
+#include "Led.h"
+
+
+Led::Led(int newPin, int newNumber) {
+  this->pin = newPin;
+  this->number = newNumber;
+  this->state = false;
+  this->blink = false;
+  this->color = {0, 0, 0};
+}
+
+bool Led::init() {
+
+  this->strip = Adafruit_NeoPixel(this->number, this->pin, NEO_GRB + NEO_KHZ800);
+  this->strip.begin();// Initialise toute les led à 'off'
+  setColorAll(255, 255, 255);
+}
+
+std::vector<int> Led::getColor() {
+  return this->color;
+}
+
+void Led::show(int ledNbr, int newR, int newV, int newB) {
+  this->color = { newR, newV, newB };
+  this->strip.setPixelColor(ledNbr, newR, newV, newB);
+  this->strip.show();
+}
+
+void Led::setColorAll(int newR, int newV, int newB) {
+  this->color = {newR, newV, newB};
+
+  int cpt;
+  for (cpt = 0; cpt < this->number; cpt++) {
+    this->strip.setPixelColor(cpt, newR, newV, newB);
+    if (this->pin == 44) {
+      this->strip.setPixelColor(0, 0, 0, 0);
+    }
+  }
+  this->strip.show();
+  delay(100);
+}
+
+void Led::setColorUnit(int ledNbr, int newR, int newV, int newB) {
+  ledNbr = abs(ledNbr);
+  if (ledNbr > this->number) show(this->number, 0, 0, 0);
+  else show(ledNbr - 1, newR, newV, newB);
+}
+
+/* Code de Quentin */
+void Led::setColor(int couleur) {
+  /*this->r = this->tabColor[couleur][0];
+    this->v = this->tabColor[couleur][1];
+    this->b = this->tabColor[couleur][2];*/
+  switch (couleur) {
+    case 0: setColorAll(10, 10, 10); //blanc
+      break;
+    case 1: setColorAll(100, 0, 0); //rouge
+      break;
+    case 2: setColorAll(0, 100, 0); //bleu
+      break;
+    case 3: setColorAll(0, 0, 100); //vert
+      break;
+    case 4: setColorAll(100, 255, 255); //turquoise
+      break;
+    case 5: setColorAll(255, 0, 50); //orange
+      break;
+    case 6: setColorAll(160, 160, 160); //gris
+      break;
+    case 7: setColorAll(153, 0, 153); //jaune
+      break;
+    case 8: setColorAll(255, 255, 51); //magenta
+      break;
+    case 9: setColorAll(120, 120, 0); //violet
+      break;
+    default:
+      break;
+  }
+}
+
+
+void Led::ledOnOff(bool state) {
+  if (state == 1) {
+    int cpt;
+    for (cpt = 0; cpt < this->number; cpt++) {
+      this->strip.setPixelColor(cpt, 255, 255, 255);
+    }
+    this->strip.show();
+  }
+  else if (state == 0) {
+    int cpt;
+    for (cpt = 0; cpt < this->number; cpt++) {
+      this->strip.setPixelColor(cpt, 0, 0, 0);
+    }
+    this->strip.show();
+  }
+}

pool/shard006/C++/0078596_init_process_reaper.cc

@@ -0,0 +1,101 @@
+// Copyright 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 "sandbox/linux/services/init_process_reaper.h"
+
+#include <signal.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+
+namespace sandbox {
+
+namespace {
+
+void DoNothingSignalHandler(int signal) {}
+
+}  // namespace
+
+bool CreateInitProcessReaper(base::Closure* post_fork_parent_callback) {
+  int sync_fds[2];
+  // We want to use send, so we can't use a pipe
+  if (socketpair(AF_UNIX, SOCK_STREAM, 0, sync_fds)) {
+    PLOG(ERROR) << "Failed to create socketpair";
+    return false;
+  }
+  pid_t child_pid = fork();
+  if (child_pid == -1) {
+    int close_ret;
+    close_ret = IGNORE_EINTR(close(sync_fds[0]));
+    DPCHECK(!close_ret);
+    close_ret = IGNORE_EINTR(close(sync_fds[1]));
+    DPCHECK(!close_ret);
+    return false;
+  }
+  if (child_pid) {
+    // In the parent, assuming the role of an init process.
+    // The disposition for SIGCHLD cannot be SIG_IGN or wait() will only return
+    // once all of our childs are dead. Since we're init we need to reap childs
+    // as they come.
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_handler = &DoNothingSignalHandler;
+    CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
+
+    int close_ret;
+    close_ret = IGNORE_EINTR(close(sync_fds[0]));
+    DPCHECK(!close_ret);
+    close_ret = shutdown(sync_fds[1], SHUT_RD);
+    DPCHECK(!close_ret);
+    if (post_fork_parent_callback)
+      post_fork_parent_callback->Run();
+    // Tell the child to continue
+    CHECK(HANDLE_EINTR(send(sync_fds[1], "C", 1, MSG_NOSIGNAL)) == 1);
+    close_ret = IGNORE_EINTR(close(sync_fds[1]));
+    DPCHECK(!close_ret);
+
+    for (;;) {
+      // Loop until we have reaped our one natural child
+      siginfo_t reaped_child_info;
+      int wait_ret =
+          HANDLE_EINTR(waitid(P_ALL, 0, &reaped_child_info, WEXITED));
+      if (wait_ret)
+        _exit(1);
+      if (reaped_child_info.si_pid == child_pid) {
+        int exit_code = 0;
+        // We're done waiting
+        if (reaped_child_info.si_code == CLD_EXITED) {
+          exit_code = reaped_child_info.si_status;
+        }
+        // Exit with the same exit code as our parent. Exit with 0 if we got
+        // signaled.
+        _exit(exit_code);
+      }
+    }
+  } else {
+    // The child needs to wait for the parent to run the callback to avoid a
+    // race condition.
+    int close_ret;
+    close_ret = IGNORE_EINTR(close(sync_fds[1]));
+    DPCHECK(!close_ret);
+    close_ret = shutdown(sync_fds[0], SHUT_WR);
+    DPCHECK(!close_ret);
+    char should_continue;
+    int read_ret = HANDLE_EINTR(read(sync_fds[0], &should_continue, 1));
+    close_ret = IGNORE_EINTR(close(sync_fds[0]));
+    DPCHECK(!close_ret);
+    if (read_ret == 1)
+      return true;
+    else
+      return false;
+  }
+}
+
+}  // namespace sandbox.

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

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2006-2012 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 "ScriptPCH.h"
+#include "ScriptedEscortAI.h"
+#include "shadow_labyrinth.h"
+
+enum eEnums
+{
+    SAY_INTRO       = -1555000,
+    SAY_AGGRO1      = -1555001,
+    SAY_AGGRO2      = -1555002,
+    SAY_AGGRO3      = -1555003,
+    SAY_HELP        = -1555004,
+    SAY_SLAY1       = -1555005,
+    SAY_SLAY2       = -1555006,
+    SAY_DEATH       = -1555007,
+
+    SPELL_BANISH            = 30231,
+    SPELL_CORROSIVE_ACID    = 33551,
+    SPELL_FEAR              = 33547,
+    SPELL_ENRAGE            = 34970
+};
+
+class boss_ambassador_hellmaw : public CreatureScript
+{
+public:
+    boss_ambassador_hellmaw() : CreatureScript("boss_ambassador_hellmaw") { }
+
+    CreatureAI* GetAI(Creature* creature) const
+    {
+        return new boss_ambassador_hellmawAI(creature);
+    }
+
+    struct boss_ambassador_hellmawAI : public npc_escortAI
+    {
+        boss_ambassador_hellmawAI(Creature* creature) : npc_escortAI(creature)
+        {
+            m_pInstance = creature->GetInstanceScript();
+        }
+
+        InstanceScript* m_pInstance;
+
+        uint32 EventCheck_Timer;
+        uint32 CorrosiveAcid_Timer;
+        uint32 Fear_Timer;
+        uint32 Enrage_Timer;
+        bool Intro;
+        bool IsBanished;
+        bool Enraged;
+
+        void Reset()
+        {
+            EventCheck_Timer = 5000;
+            CorrosiveAcid_Timer = urand(5000, 10000);
+            Fear_Timer = urand(25000, 30000);
+            Enrage_Timer = 180000;
+            Intro = false;
+            IsBanished = true;
+            Enraged = false;
+
+            if (m_pInstance && me->isAlive())
+            {
+                if (m_pInstance->GetData(TYPE_OVERSEER) != DONE)
+                    DoCast(me, SPELL_BANISH, true);
+            }
+        }
+
+        void JustReachedHome()
+        {
+            if (m_pInstance)
+                m_pInstance->SetData(TYPE_HELLMAW, FAIL);
+        }
+
+        void MoveInLineOfSight(Unit* who)
+        {
+            if (me->HasAura(SPELL_BANISH))
+                return;
+
+            npc_escortAI::MoveInLineOfSight(who);
+        }
+
+        void WaypointReached(uint32 /*i*/)
+        {
+        }
+
+        void DoIntro()
+        {
+            if (me->HasAura(SPELL_BANISH))
+                me->RemoveAurasDueToSpell(SPELL_BANISH);
+
+            IsBanished = false;
+            Intro = true;
+
+            if (m_pInstance)
+            {
+                if (m_pInstance->GetData(TYPE_HELLMAW) != FAIL)
+                {
+                    DoScriptText(SAY_INTRO, me);
+                    Start(true, false, 0, NULL, false, true);
+                }
+
+                m_pInstance->SetData(TYPE_HELLMAW, IN_PROGRESS);
+            }
+        }
+
+        void EnterCombat(Unit* /*who*/)
+        {
+            DoScriptText(RAND(SAY_AGGRO1, SAY_AGGRO2, SAY_AGGRO3), me);
+        }
+
+        void KilledUnit(Unit* /*victim*/)
+        {
+            DoScriptText(RAND(SAY_SLAY1, SAY_SLAY2), me);
+        }
+
+        void JustDied(Unit* /*victim*/)
+        {
+            DoScriptText(SAY_DEATH, me);
+
+            if (m_pInstance)
+                m_pInstance->SetData(TYPE_HELLMAW, DONE);
+        }
+
+        void UpdateAI(const uint32 diff)
+        {
+            if (!Intro && !HasEscortState(STATE_ESCORT_ESCORTING))
+            {
+                if (EventCheck_Timer <= diff)
+                {
+                    if (m_pInstance)
+                    {
+                        if (m_pInstance->GetData(TYPE_OVERSEER) == DONE)
+                        {
+                            DoIntro();
+                            return;
+                        }
+                    }
+                    EventCheck_Timer = 5000;
+                    return;
+                }
+                else
+                {
+                    EventCheck_Timer -= diff;
+                    return;
+                }
+            }
+
+            npc_escortAI::UpdateAI(diff);
+
+            if (!UpdateVictim())
+                return;
+
+            if (me->HasAura(SPELL_BANISH, 0))
+            {
+                EnterEvadeMode();
+                return;
+            }
+
+            if (CorrosiveAcid_Timer <= diff)
+            {
+                DoCast(me->getVictim(), SPELL_CORROSIVE_ACID);
+                CorrosiveAcid_Timer = urand(15000, 25000);
+            } else CorrosiveAcid_Timer -= diff;
+
+            if (Fear_Timer <= diff)
+            {
+                DoCast(me, SPELL_FEAR);
+                Fear_Timer = urand(20000, 35000);
+            } else Fear_Timer -= diff;
+
+            if (IsHeroic())
+            {
+                if (!Enraged && Enrage_Timer <= diff)
+                {
+                    DoCast(me, SPELL_ENRAGE);
+                    Enraged = true;
+                } else Enrage_Timer -= diff;
+            }
+        }
+    };
+};
+
+void AddSC_boss_ambassador_hellmaw()
+{
+    new boss_ambassador_hellmaw();
+}

pool/shard006/C++/0078614_parser.cpp

@@ -0,0 +1,157 @@
+/* Uses Jsoncpp, reference here:
+ * http://open-source-parsers.github.io/jsoncpp-docs/
+ */
+#include "parser.h"
+#include <iostream>
+
+
+Parser::Parser(std::string filename)
+{
+    init();
+
+    std::ifstream contents(filename, std::ifstream::binary);
+
+    /* root is the top-level handle on the json object we parse */
+    Json::Reader reader;
+    if (reader.parse(contents, root, false) == false) {
+        std::cerr << "Error parsing scene" << std::endl;
+    }
+}
+
+Parser::Parser(Json::Value root) : root(root)
+{
+    init();
+}
+
+void Parser::init()
+{
+    /* We map object types to their JSON converters. */
+    converters.insert(
+        std::make_pair("sphere", (json_converter)&Parser::json_to_sphere)
+    );
+    converters.insert(
+        std::make_pair("box", (json_converter)&Parser::json_to_box)
+    );
+    converters.insert(
+        std::make_pair("point_light",
+                       (json_converter)&Parser::json_to_point_light)
+    );
+}
+
+bool Parser::valid_object_type(std::string type)
+{
+    /* Is the type in the map? */
+    return converters.find(type) != converters.end();
+}
+
+vector3_t Parser::json_to_vector3(Json::Value json_vector)
+{
+    return vector3_t(
+        json_vector["x"].asDouble(),
+        json_vector["y"].asDouble(),
+        json_vector["z"].asDouble()
+        );
+}
+
+color_t Parser::json_to_color(Json::Value json_color)
+{
+    return color_t(
+        json_color["r"].asDouble(),
+        json_color["g"].asDouble(),
+        json_color["b"].asDouble(),
+        json_color["a"].asDouble()
+        );
+}
+
+material_t Parser::json_to_material(Json::Value json_material)
+{
+    material_t mat = material_t(
+        json_to_color(json_material["ambient"]),
+        json_to_color(json_material["diffuse"]),
+        json_to_color(json_material["specular"]),
+        json_to_color(json_material["emission"]),
+        json_material["reflection"].asDouble()
+    );
+
+    /* Pptionally set refraction amount, and index of refraction.
+       If unspecified default to 0 and 1 respectively. */
+    mat.refraction =
+        json_material.get("refraction", Json::Value(0.0)).asDouble();
+    mat.refraction_index =
+        json_material.get("refraction_index", Json::Value(1)).asDouble();
+    mat.texture = json_material.get("texture", Json::Value(false)).asBool();
+
+
+    return mat;
+}
+
+Sphere *Parser::json_to_sphere(Json::Value json_sphere)
+{
+    return new Sphere(
+        json_to_vector3(json_sphere["loc"]),
+        json_to_material(json_sphere["material"]),
+        json_sphere["radius"].asDouble()
+        );
+}
+
+Box *Parser::json_to_box(Json::Value json_box)
+{
+    return new Box(
+        json_to_vector3(json_box["min"]),
+        json_to_vector3(json_box["max"]),
+        json_to_material(json_box["material"])
+    );
+}
+
+PointLight *Parser::json_to_point_light(Json::Value json_point_light) {
+
+    return new PointLight(
+            json_to_vector3(json_point_light["loc"]),
+            json_to_color(json_point_light["intensity"]));
+}
+
+scene_t Parser::parse()
+{
+    scene_t scene;
+
+    /* The list of scene objects is referenced by key:
+     * "scene_objects"
+     */
+    Json::Value scene_objs_json = root["scene_objects"];
+    /* Create scene_obj from each item in JSON "scene_objects"[]
+     * based on object_type; append object into scene_objs vector
+     */
+    for (Json::ValueIterator itr = scene_objs_json.begin();
+         itr != scene_objs_json.end(); itr++) {
+
+        /* We branch based on the type of object we encounter
+         * in the scene file.
+         */
+        std::string type = (*itr)["object_type"].asString();
+        if (valid_object_type(type)) {
+            json_converter c = converters[type];
+            scene.objects.push_back((this->*c)(*itr));
+        }
+        else {
+            std::cerr << "UNKNOWN TYPE " << type << std::endl;
+        }
+    }
+    Json::Value scene_lights_json = root["scene_lights"];
+    for (Json::ValueIterator itr = scene_lights_json.begin();
+         itr != scene_lights_json.end(); itr++) {
+
+        /* We branch based on the type of object we encounter
+         * in the scene file.
+         */
+        std::string type = (*itr)["object_type"].asString();
+        if (valid_object_type(type)) {
+            json_converter c = converters[type];
+            scene.lights.push_back((this->*c)(*itr));
+        }
+        else {
+            std::cerr << "UNKNOWN TYPE " << type << std::endl;
+        }
+    }
+
+    return scene;
+}

pool/shard006/C++/0078616_DrawingElement.cpp

@@ -0,0 +1,230 @@
+//
+//  DrawingElement.cpp
+//
+// Sketchup C++ Wrapper for C API
+// MIT License
+//
+// Copyright (c) 2017 Tom Kaneko
+//
+// 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.
+//
+
+// Macro for getting rid of unused variables commonly for assert checking
+#define _unused(x) ((void)(x))
+
+#include "SUAPI-CppWrapper/model/DrawingElement.hpp"
+
+#include <cassert>
+#include <stdexcept>
+
+#include "SUAPI-CppWrapper/model/Layer.hpp"
+#include "SUAPI-CppWrapper/model/Material.hpp"
+#include "SUAPI-CppWrapper/Geometry.hpp"
+
+
+namespace CW {
+
+DrawingElement::DrawingElement(SUDrawingElementRef drawing_element, bool attached):
+  Entity(SUDrawingElementToEntity(drawing_element), attached)
+{}
+
+
+DrawingElement::DrawingElement(const DrawingElement& other, SUDrawingElementRef element_ref):
+  Entity(other, SUDrawingElementToEntity(element_ref))
+{}
+
+DrawingElement::DrawingElement():
+  Entity()
+{}
+
+
+/** Copy assignment operator */
+DrawingElement& DrawingElement::operator=(const DrawingElement& other) {
+  if (!other.m_attached && SUIsValid(other.m_entity)) {
+    this->copy_properties_from(other);
+  }
+  Entity::operator=(other);
+  return (*this);
+}
+
+
+SUDrawingElementRef DrawingElement::ref() const {
+  return SUDrawingElementFromEntity(m_entity);
+}
+
+
+DrawingElement::operator SUDrawingElementRef() const {
+  return this->ref();
+}
+
+
+BoundingBox3D DrawingElement::bounds() {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::bounds(): DrawingElement is null");
+  }
+  SUBoundingBox3D box;
+  SUResult res = SUDrawingElementGetBoundingBox(this->ref(), &box);
+  assert(res == SU_ERROR_NONE); _unused(res);
+  return BoundingBox3D(box);
+}
+
+
+bool DrawingElement::copy_properties_from(const DrawingElement& element) {
+  bool success = this->casts_shadows(element.casts_shadows());
+  if (!success)
+    return false;
+  success = this->hidden(element.hidden());
+  if (!success)
+    return false;
+  success = this->receive_shadows(element.receive_shadows());
+  if (!success)
+    return false;
+  Layer elem_layer = element.layer();
+  success = this->layer(elem_layer);
+  if (!success)
+    return false;
+  success = this->material(element.material());
+  if (!success)
+    return false;
+  
+  return true;
+}
+
+
+bool DrawingElement::casts_shadows() const {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::casts_shadows(): DrawingElement is null");
+  }
+  bool cast_shadows_flag;
+  SUResult res = SUDrawingElementGetCastsShadows(this->ref(), &cast_shadows_flag);
+  assert(res == SU_ERROR_NONE); _unused(res);
+  return cast_shadows_flag;
+}
+
+
+bool DrawingElement::casts_shadows(bool casts_shadows) {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::casts_shadows(): DrawingElement is null");
+  }
+  SUResult res = SUDrawingElementSetCastsShadows(this->ref(), casts_shadows);
+  if (res == SU_ERROR_NONE) {
+    return true;
+  }
+  return false;
+}
+
+
+bool DrawingElement::hidden() const {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::hidden(): DrawingElement is null");
+  }
+  bool hide_flag;
+  SUDrawingElementGetHidden(this->ref(), &hide_flag);
+  return hide_flag;
+}
+
+
+bool DrawingElement::hidden(bool hidden) {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::hidden(): DrawingElement is null");
+  }
+  SUResult res = SUDrawingElementSetHidden(this->ref(), hidden);
+  if (res == SU_ERROR_NONE) {
+    return true;
+  }
+  return false;
+}
+
+
+Layer DrawingElement::layer() const {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::layer(): DrawingElement is null");
+  }
+  SULayerRef layer_ref = SU_INVALID;
+  SUResult res = SUDrawingElementGetLayer(this->ref(), &layer_ref);
+  if (res == SU_ERROR_NULL_POINTER_OUTPUT || res == SU_ERROR_NO_DATA) {
+    return Layer();
+  }
+  assert(res == SU_ERROR_NONE); _unused(res);
+  return Layer(layer_ref, true);
+}
+
+
+bool DrawingElement::layer(Layer& layer){
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::layer(): DrawingElement is null");
+  }
+  SUResult res = SUDrawingElementSetLayer(this->ref(), layer);
+  if (res == SU_ERROR_NONE) {
+    layer.attached(true);
+    return true;
+  }
+  return false;
+}
+
+
+Material DrawingElement::material() const {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::material(): DrawingElement is null");
+  }
+  SUMaterialRef material_ref = SU_INVALID;
+  SUResult res = SUDrawingElementGetMaterial(this->ref(), &material_ref);
+  if (res == SU_ERROR_NO_DATA || res == SU_ERROR_NULL_POINTER_OUTPUT) {
+    return Material();
+  }
+  assert(res == SU_ERROR_NONE); _unused(res);
+  return Material(material_ref, true);
+}
+
+
+bool DrawingElement::material(const Material& material) {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::material(): DrawingElement is null");
+  }
+  SUResult res = SUDrawingElementSetMaterial(this->ref(), material);
+  if (res == SU_ERROR_NONE) {
+    return true;
+  }
+  return false;
+}
+
+
+bool DrawingElement::receive_shadows() const {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::receive_shadows(): DrawingElement is null");
+  }
+  bool receives_shadows_flag;
+  SUResult res = SUDrawingElementGetReceivesShadows(this->ref(), &receives_shadows_flag);
+  assert (res == SU_ERROR_NONE); _unused(res);
+  return receives_shadows_flag;
+}
+
+
+bool DrawingElement::receive_shadows(bool receives_shadows_flag) {
+  if (SUIsInvalid(m_entity)) {
+    throw std::logic_error("CW::DrawingElement::receive_shadows(): DrawingElement is null");
+  }
+  SUResult res = SUDrawingElementSetReceivesShadows(this->ref(), receives_shadows_flag);
+  if (res == SU_ERROR_NONE) {
+    return true;
+  }
+  return false;
+}
+
+} /* namespace CW */

pool/shard006/C++/0078617_stackdriver_client_test.cc

@@ -0,0 +1,215 @@
+/* Copyright 2020 Google LLC
+
+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.
+==============================================================================*/
+
+#include "monitoring/stackdriver_client.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <list>
+
+#include "google/monitoring/v3/metric_service_mock.grpc.pb.h"
+#include "google/protobuf/util/json_util.h"
+
+namespace tensorflow {
+namespace monitoring {
+
+using ::testing::_;
+using ::testing::Return;
+
+namespace {
+inline void SetPointValue(int64 value, Point* point) {
+  point->value_type = ValueType::kInt64;
+  point->int64_value = value;
+}
+
+inline void SetPointValue(std::list<double> value, Point* point) {
+  point->value_type = ValueType::kHistogram;
+  HistogramProto& histogram = point->histogram_value;
+
+  // 2 buckets: (-oo, 0] and (0, +oo)
+  histogram.add_bucket_limit(0.0);
+  histogram.add_bucket(0.0);
+  histogram.add_bucket_limit(DBL_MAX);
+  histogram.add_bucket(0.0);
+
+  if (value.empty()) {
+    return;
+  }
+
+  histogram.set_min(value.front());
+  histogram.set_max(value.front());
+  histogram.set_num(value.size());
+  for (double sample : value) {
+    histogram.set_min(std::min(histogram.min(), sample));
+    histogram.set_max(std::max(histogram.max(), sample));
+    histogram.set_sum(histogram.sum() + sample);
+    histogram.set_sum_squares(histogram.sum_squares() + sample * sample);
+    size_t bucket_id = (sample < 0.0) ? 0 : 1;
+    histogram.set_bucket(bucket_id, histogram.bucket(bucket_id) + 1);
+  }
+}
+
+template <typename T>
+std::unique_ptr<PointSet> MakePointSet(std::string name, int64 time_millis,
+                                       std::initializer_list<T> values) {
+  auto point_set = std::make_unique<PointSet>();
+  point_set->metric_name = std::move(name);
+  for (auto& value : values) {
+    auto point = std::make_unique<Point>();
+    SetPointValue(std::move(value), point.get());
+    point->end_timestamp_millis = time_millis;
+    point_set->points.emplace_back(std::move(point));
+  }
+  return point_set;
+}
+
+MATCHER_P(EqualsRequest, expected, "The expected request does not match") {
+  *result_listener << "as the expected is " << expected.DebugString();
+  return expected.SerializeAsString() == arg.SerializeAsString();
+}
+
+}  // namespace
+
+TEST(StackdriverClientTest, CreateTimeSeries) {
+  std::map<string, std::unique_ptr<PointSet>> point_set_map;
+  point_set_map["/metric_1"] = MakePointSet(
+      "/metric_1",  // metric type is "custom.googleapis.com/metric_1"
+      12345,        // timestamp is 12 seconds and 345,000,000 nanoseconds
+      {33, 44});    // the first number 33 is exported as int64_value
+  point_set_map["/metric_2"] = MakePointSet(
+      "/metric_2",  // metric type is "custom.googleapis.com/metric_2"
+      12345,        // timestamp is 12 seconds and 345,000,000 nanoseconds
+      {std::list<double>{-1.0, 1.0}});  // one histogram containing {-1.0, 1.0}
+
+  const std::string expected_request_json = R"(
+  {
+    "name": "projects/test_project",
+    "time_series": [
+      {
+        "metric": {
+          "type": "custom.googleapis.com/metric_1",
+        },
+        "resource": {
+          "type": "global"
+        },
+        "points": {
+          "interval": {
+            "end_time": {
+              "seconds": 12,
+              "nanos": 345000000,
+            },
+          },
+          "value": {
+            "int64_value": 33,
+          },
+        },
+      },
+      {
+        "metric": {
+          "type": "custom.googleapis.com/metric_2",
+        },
+        "resource": {
+          "type": "global"
+        },
+        "points": {
+          "interval": {
+            "end_time": {
+              "seconds": 12,
+              "nanos": 345000000,
+            },
+          },
+          "value": {
+            "distribution_value": {
+              "count": 2,
+              "mean": 0.0,
+              "sum_of_squared_deviation": 2.0,
+              "bucket_options": {
+                "explicit_buckets": {
+                  "bounds": [
+                    0.0,
+                  ],
+                },
+              },
+              "bucket_counts": [
+                1,
+                1,
+              ],
+            }
+          },
+        },
+      },
+    ],
+  }
+  )";
+  google::monitoring::v3::CreateTimeSeriesRequest expected_request;
+  auto status = google::protobuf::util::JsonStringToMessage(
+      expected_request_json, &expected_request);
+  ASSERT_TRUE(status.ok()) << status.error_message();
+
+  auto mock_metric_service =
+      std::make_unique<google::monitoring::v3::grpc::MockMetricServiceStub>();
+  EXPECT_CALL(*mock_metric_service,
+              CreateTimeSeries(_, EqualsRequest(expected_request), _))
+      .WillOnce(Return(::grpc::Status::OK));
+  StackdriverClient client({"test_project"}, std::move(mock_metric_service));
+  EXPECT_OK(client.CreateTimeSeries(point_set_map));
+}
+
+TEST(StackdriverClientTest, CreateMetricDescriptor) {
+  MetricDescriptor metric_descriptor{
+      .name = "metric_1",
+      .description = "desc",
+      .label_names = {"a", "b"},
+      .metric_kind = MetricKind::kCumulative,
+      .value_type = ValueType::kInt64,
+  };
+
+  const std::string expected_request_json = R"(
+  {
+    name: "projects/test_project",
+    metric_descriptor: {
+      name: "metric_1",
+      type: "custom.googleapis.commetric_1",
+      description: "desc",
+      labels: [
+        {
+          key: "a"
+        },
+        {
+          key: "b"
+        }
+      ],
+      metric_kind: 3,
+      value_type: 2,
+    },
+  }
+  )";
+  google::monitoring::v3::CreateMetricDescriptorRequest expected_request;
+  auto status = google::protobuf::util::JsonStringToMessage(
+      expected_request_json, &expected_request);
+  ASSERT_TRUE(status.ok()) << status.error_message();
+
+  auto mock_metric_service =
+      std::make_unique<google::monitoring::v3::grpc::MockMetricServiceStub>();
+  EXPECT_CALL(*mock_metric_service,
+              CreateMetricDescriptor(_, EqualsRequest(expected_request), _))
+      .WillOnce(Return(::grpc::Status::OK));
+  StackdriverClient client({"test_project"}, std::move(mock_metric_service));
+  EXPECT_OK(client.CreateMetricDescriptor(metric_descriptor));
+}
+
+}  // namespace monitoring
+}  // namespace tensorflow

pool/shard006/C++/0078620_qgsclassificationjenks.cpp

@@ -0,0 +1,192 @@
+/***************************************************************************
+    qgsclassificationjenks.h
+    ---------------------
+    begin                : September 2019
+    copyright            : (C) 2019 by Denis Rouzaud
+    email                : denis@opengis.ch
+ ***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <limits>
+#include "qgsclassificationjenks.h"
+#include "qgsapplication.h"
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
+#include <QRandomGenerator>
+#endif
+
+QgsClassificationJenks::QgsClassificationJenks()
+  : QgsClassificationMethod()
+{
+
+}
+
+QString QgsClassificationJenks::name() const
+{
+  return QObject::tr( "Natural Breaks (Jenks)" );
+}
+
+QString QgsClassificationJenks::id() const
+{
+  return QStringLiteral( "Jenks" );
+}
+
+QgsClassificationMethod *QgsClassificationJenks::clone() const
+{
+  QgsClassificationJenks *c = new QgsClassificationJenks();
+  copyBase( c );
+  return c;
+}
+
+QIcon QgsClassificationJenks::icon() const
+{
+  return QgsApplication::getThemeIcon( "classification_methods/mClassificationNaturalBreak.svg" );
+}
+
+
+QList<double> QgsClassificationJenks::calculateBreaks( double &minimum, double &maximum,
+    const QList<double> &values, int nclasses )
+{
+  // Jenks Optimal (Natural Breaks) algorithm
+  // Based on the Jenks algorithm from the 'classInt' package available for
+  // the R statistical prgramming language, and from Python code from here:
+  // http://danieljlewis.org/2010/06/07/jenks-natural-breaks-algorithm-in-python/
+  // and is based on a JAVA and Fortran code available here:
+  // https://stat.ethz.ch/pipermail/r-sig-geo/2006-March/000811.html
+
+  // Returns class breaks such that classes are internally homogeneous while
+  // assuring heterogeneity among classes.
+
+  if ( values.isEmpty() )
+    return QList<double>();
+
+  if ( nclasses <= 1 )
+  {
+    return QList<double>() <<  maximum;
+  }
+
+  if ( nclasses >= values.size() )
+  {
+    return values;
+  }
+
+  QVector<double> sample;
+  QVector<double> sorted;
+
+  // if we have lots of values, we need to take a random sample
+  if ( values.size() > mMaximumSize )
+  {
+    // for now, sample at least maximumSize values or a 10% sample, whichever
+    // is larger. This will produce a more representative sample for very large
+    // layers, but could end up being computationally intensive...
+
+    sample.resize( std::max( mMaximumSize, static_cast<int>( values.size() ) / 10 ) );
+
+    QgsDebugMsgLevel( QStringLiteral( "natural breaks (jenks) sample size: %1" ).arg( sample.size() ), 2 );
+    QgsDebugMsgLevel( QStringLiteral( "values:%1" ).arg( values.size() ), 2 );
+
+    sample[ 0 ] = minimum;
+    sample[ 1 ] = maximum;
+
+    sorted = values.toVector();
+    std::sort( sorted.begin(), sorted.end() );
+
+    int j = -1;
+
+    // loop through all values in initial array
+    // skip the first value as it is a minimum one
+    // skip the last value as that one is a maximum one
+    // and those are already in the sample as items 0 and 1
+    for ( int i = 1; i < sorted.size() - 2; i++ )
+    {
+      if ( ( i * ( mMaximumSize - 2 ) / ( sorted.size() - 2 ) ) > j )
+      {
+        j++;
+        sample[ j + 2 ] = sorted[ i ];
+      }
+    }
+  }
+  else
+  {
+    sample = values.toVector();
+  }
+
+  const int n = sample.size();
+
+  // sort the sample values
+  std::sort( sample.begin(), sample.end() );
+
+  QVector< QVector<int> > matrixOne( n + 1 );
+  QVector< QVector<double> > matrixTwo( n + 1 );
+
+  for ( int i = 0; i <= n; i++ )
+  {
+    matrixOne[i].resize( nclasses + 1 );
+    matrixTwo[i].resize( nclasses + 1 );
+  }
+
+  for ( int i = 1; i <= nclasses; i++ )
+  {
+    matrixOne[0][i] = 1;
+    matrixOne[1][i] = 1;
+    matrixTwo[0][i] = 0.0;
+    for ( int j = 2; j <= n; j++ )
+    {
+      matrixTwo[j][i] = std::numeric_limits<double>::max();
+    }
+  }
+
+  for ( int l = 2; l <= n; l++ )
+  {
+    double s1 = 0.0;
+    double s2 = 0.0;
+    int w = 0;
+
+    double v = 0.0;
+
+    for ( int m = 1; m <= l; m++ )
+    {
+      const int i3 = l - m + 1;
+
+      const double val = sample[ i3 - 1 ];
+
+      s2 += val * val;
+      s1 += val;
+      w++;
+
+      v = s2 - ( s1 * s1 ) / static_cast< double >( w );
+      const int i4 = i3 - 1;
+      if ( i4 != 0 )
+      {
+        for ( int j = 2; j <= nclasses; j++ )
+        {
+          if ( matrixTwo[l][j] >= v + matrixTwo[i4][j - 1] )
+          {
+            matrixOne[l][j] = i4;
+            matrixTwo[l][j] = v + matrixTwo[i4][j - 1];
+          }
+        }
+      }
+    }
+    matrixOne[l][1] = 1;
+    matrixTwo[l][1] = v;
+  }
+
+  QVector<double> breaks( nclasses );
+  breaks[nclasses - 1] = sample[n - 1];
+
+  for ( int j = nclasses, k = n; j >= 2; j-- )
+  {
+    const int id = matrixOne[k][j] - 1;
+    breaks[j - 2] = sample[id];
+    k = matrixOne[k][j] - 1;
+  }
+
+  return breaks.toList();
+}

pool/shard006/C++/0078623_RPC.cpp

@@ -0,0 +1,212 @@
+#include "RPC.h"
+#include "../../../General/Driver/Network/LibEvent/ZNetworkLibEvent.h"
+#include "../../../Core/Driver/Thread/Pthread/ZThreadPthread.h"
+#include "../../../General/Misc/RemoteProxy.h"
+
+using namespace PaintsNow;
+
+class Foo : public TReflected<Foo, IScript::Library> {
+public:
+	Foo() {}
+
+	virtual TObject<IReflect>& operator () (IReflect& reflect) {
+		BaseClass::operator () (reflect);
+		if (reflect.IsReflectMethod()) {
+			ReflectMethod(RequestNewFoo)[ScriptMethod = "NewFoo"];
+		}
+
+		return *this;
+	}
+
+	void RequestNewFoo(IScript::Request& request, int a, const String& str) {
+
+	}
+};
+
+class PrefabFactory : public TWrapper<IScript::Object*, const String&> {
+public:
+	PrefabFactory(IThread& threadApi) : TWrapper<IScript::Object*, const String&>(Wrap(this, &PrefabFactory::CreateObject)), thread(threadApi) {}
+	class Prefab : public TReflected<Prefab, IScript::Object> {
+	public:
+		virtual TObject<IReflect>& operator () (IReflect& reflect) {
+			BaseClass::operator () (reflect);
+			if (reflect.IsReflectMethod()) {
+				ReflectMethod(Test)[ScriptMethod];
+				ReflectMethod(Complete)[ScriptMethod];
+			}
+
+			return *this;
+		}
+
+		void Test(IScript::Request& request, uint32_t p, const String& message, int value) {
+			printf("Message: %s : %d, %d\n", message.c_str(), p, value);
+		}
+
+		void Complete(IScript::Request& request, const String& message) {
+			printf("Complete: %s\n", message.c_str());
+		}
+
+		virtual void ScriptUninitialize(IScript::Request& request) {}
+	};
+
+	IScript::Object* CreateObject(const String& entry) const {
+		printf("Hello %s \n", entry.c_str());
+		return new Prefab();
+	}
+
+	IThread& thread;
+};
+
+void Then(IScript::Request& request) {
+	IScript::Request::ArrayStart ns;
+	request >> ns;
+	for (size_t i = 0; i < ns.count; i++) {
+		String name;
+		request >> begintable;
+		request << key("Name") >> name;
+		printf("Name: %s\n", name.c_str());
+		IScript::Request::ArrayStart ts;
+		request << key("Arguments") >> ts;
+		for (size_t j = 0; j < ts.count; j++) {
+			request >> name;
+			printf("\tArg[%d]: %s\n", (int)j, name.c_str());
+		}
+		request << endarray;
+		request << endtable;
+	}
+	request << endarray;
+}
+
+void After(IScript::Request& request, IScript::Request::Ref prefab) {
+	request.DoLock();
+	request.Push();
+	request.Call(prefab, 0, String("abcasdfwhaodkjfo;asld;asdgihaosdfi"));
+	request.Pop();
+	request.UnLock();
+}
+
+class MyPrefab : public TReflected<MyPrefab, IReflectObjectComplex> {
+public:
+	virtual TObject<IReflect>& operator () (IReflect& reflect) {
+		BaseClass::operator () (reflect);
+		if (reflect.IsReflectProperty()) {
+			ReflectProperty(Test)[ScriptRemoteMethod(&PrefabFactory::Prefab::Test)];
+			ReflectProperty(Complete)[ScriptRemoteMethod(&PrefabFactory::Prefab::Complete)];
+		}
+		return *this;
+	}
+	TWrapper<void, const IScript::Request::AutoWrapperBase&, IScript::Request&, uint32_t, const String&, int> Test;
+	TWrapper<void, const IScript::Request::AutoWrapperBase&, IScript::Request&, const String&> Complete;
+} myPrefab;
+
+void OnFinish(IScript::Request& request) {
+	printf("FINISH!\n");
+}
+
+void OnQueryPrefab(IScript::Request& request, IReflectObject& inter, const IScript::Request::Ref& ref) {
+	assert(&myPrefab == &inter);
+	String s = "Hello, World";
+
+	request.DoLock();
+	request.Push();
+	myPrefab.Test(request.Adapt(Wrap(OnFinish)), request, 666, s, 1234);
+	request.Pop();
+	request.Push();
+	myPrefab.Complete(request.Adapt(Wrap(OnFinish)), request, s);
+	request.Pop();
+	request.UnLock();
+
+	/*
+	request.DoLock();
+	request.Push();
+	request.Call(ref, 0, "abcasdfwhaodkjfo;asld;asdgihaosdfi");
+	request.Pop();
+	request.UnLock();*/
+}
+
+void OnQuery(IScript::Request& request, IReflectObject& inter, const IScript::Request::Ref& ref) {
+	RemoteFactory& testInterface = static_cast<RemoteFactory&>(inter);
+	IScript::Request::Ref prefab;
+	request.DoLock();
+	request.Push();
+
+	// You can choose either sync or async call.
+	testInterface.NewObject(IScript::Request::Sync(), request, "Prefab");
+	request >> prefab;
+
+	request.QueryInterface(Wrap(OnQueryPrefab), myPrefab, prefab);
+	request.Pop();
+	request.UnLock();
+
+	/*
+	if (prefab) {
+	request.Push();
+	request.Call(prefab, 0, "abcasdfwhaodkjfo;asld;asdgihaosdfi");
+	request.Pop();
+	}*/
+}
+
+void OnConnect(IScript::Request& request, bool isServer, RemoteProxy::STATUS status, const String& info) {
+	// sync call
+	printf("Connecting ... %d, %d\n", isServer, status);
+}
+
+void TestRPC() {
+}
+
+bool RPC::Initialize() {
+	return true;
+}
+
+bool RPC::Run(int randomSeed, int length) {
+	ZThreadPthread uniqueThreadApi;
+	Foo foo;
+	IScript::Library* module = foo.QueryInterface(UniqueType<IScript::Library>());
+	IScript::Object* object = foo.QueryInterface(UniqueType<IScript::Object>());
+
+	ZNetworkLibEvent network(uniqueThreadApi);
+	ITunnel& tunnel = network;
+
+	const PrefabFactory factory(uniqueThreadApi);
+
+	RemoteProxy serverProxy(uniqueThreadApi, tunnel, factory, "127.0.0.1:16384", Wrap(OnConnect));
+	serverProxy.Run();
+
+	for (int i = 0; i < length; i++) {
+		RemoteProxy clientProxy(uniqueThreadApi, tunnel, factory, "127.0.0.1:16385");
+		clientProxy.Run();
+		// async create request
+		IScript::Request* r = clientProxy.NewRequest("127.0.0.1:16384");
+		if (r == nullptr) {
+			printf("Unable to connect RPC server. Stop.\n");
+			break;
+		}
+
+		r->Destroy();
+		r = clientProxy.NewRequest("127.0.0.1:16384");
+
+		IScript::Request& request = *r;
+		request.DoLock();
+		request.Push();
+		IScript::Request::Ref global = request.Load("Global", "Initialize");
+		RemoteFactory testInterface;
+		request.QueryInterface(Wrap(OnQuery), testInterface, global);
+		// parse result
+		request.Pop();
+		request.UnLock();
+		getchar();
+
+		// Close connection
+		r->Destroy();
+	}
+
+	return true;
+}
+
+void RPC::Summary() {}
+
+TObject<IReflect>& RPC::operator () (IReflect& reflect) {
+	BaseClass::operator () (reflect);
+
+	return *this;
+}

pool/shard006/C++/0078634_checkpoints.cpp

@@ -0,0 +1,146 @@
+// Copyright (c) 2009-2012 The GulfCoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/foreach.hpp>
+
+#include "checkpoints.h"
+
+#include "main.h"
+#include "uint256.h"
+
+namespace Checkpoints
+{
+    typedef std::map<int, uint256> MapCheckpoints;
+
+    // How many times we expect transactions after the last checkpoint to
+    // be slower. This number is a compromise, as it can't be accurate for
+    // every system. When reindexing from a fast disk with a slow CPU, it
+    // can be up to 20, while when downloading from a slow network with a
+    // fast multicore CPU, it won't be much higher than 1.
+    static const double fSigcheckVerificationFactor = 5.0;
+
+    struct CCheckpointData {
+        const MapCheckpoints *mapCheckpoints;
+        int64 nTimeLastCheckpoint;
+        int64 nTransactionsLastCheckpoint;
+        double fTransactionsPerDay;
+    };
+
+    bool fEnabled = true;
+
+    // What makes a good checkpoint block?
+    // + Is surrounded by blocks with reasonable timestamps
+    //   (no blocks before with a timestamp after, none after with
+    //    timestamp before)
+    // + Contains no strange transactions
+    static MapCheckpoints mapCheckpoints =
+        boost::assign::map_list_of
+        (  0, uint256("0x00000000b37e82110be5b83b20707ddbb60ac0eb3e7d6f65cf29661a55128ed3"))
+		(  6870, uint256("0x0000000000013e4806cf9d4c107afe309c750e346b4be4c10ce78a5f8eb4dbd3"))
+        ;
+    static const CCheckpointData data = {
+        &mapCheckpoints,
+        1492065540, // * UNIX timestamp of last checkpoint block
+        6900,   // * total number of transactions between genesis and last checkpoint
+    };
+
+    static MapCheckpoints mapCheckpointsTestnet =
+        boost::assign::map_list_of
+        (  0, uint256("00000000b37e82110be5b83b20707ddbb60ac0eb3e7d6f65cf29661a55128ed3"))
+        ;
+    static const CCheckpointData dataTestnet = {
+        &mapCheckpointsTestnet,
+    };
+
+    static MapCheckpoints mapCheckpointsRegtest =
+        boost::assign::map_list_of
+        ( 0, uint256("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"))
+        ;
+    static const CCheckpointData dataRegtest = {
+        &mapCheckpointsRegtest,
+        0,
+        0,
+        0
+    };
+
+    const CCheckpointData &Checkpoints() {
+        if (Params().NetworkID() == CChainParams::TESTNET)
+            return dataTestnet;
+        else if (Params().NetworkID() == CChainParams::MAIN)
+            return data;
+        else
+            return dataRegtest;
+    }
+
+    bool CheckBlock(int nHeight, const uint256& hash)
+    {
+        if (!fEnabled)
+            return true;
+
+        const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
+
+        MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
+        if (i == checkpoints.end()) return true;
+        return hash == i->second;
+    }
+
+    // Guess how far we are in the verification process at the given block index
+    double GuessVerificationProgress(CBlockIndex *pindex) {
+        if (pindex==NULL)
+            return 0.0;
+
+        int64 nNow = time(NULL);
+
+        double fWorkBefore = 0.0; // Amount of work done before pindex
+        double fWorkAfter = 0.0;  // Amount of work left after pindex (estimated)
+        // Work is defined as: 1.0 per transaction before the last checkoint, and
+        // fSigcheckVerificationFactor per transaction after.
+
+        const CCheckpointData &data = Checkpoints();
+
+        if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
+            double nCheapBefore = pindex->nChainTx;
+            double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
+            double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint)/86400.0*data.fTransactionsPerDay;
+            fWorkBefore = nCheapBefore;
+            fWorkAfter = nCheapAfter + nExpensiveAfter*fSigcheckVerificationFactor;
+        } else {
+            double nCheapBefore = data.nTransactionsLastCheckpoint;
+            double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
+            double nExpensiveAfter = (nNow - pindex->nTime)/86400.0*data.fTransactionsPerDay;
+            fWorkBefore = nCheapBefore + nExpensiveBefore*fSigcheckVerificationFactor;
+            fWorkAfter = nExpensiveAfter*fSigcheckVerificationFactor;
+        }
+
+        return fWorkBefore / (fWorkBefore + fWorkAfter);
+    }
+
+    int GetTotalBlocksEstimate()
+    {
+        if (!fEnabled)
+            return 0;
+
+        const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
+
+        return checkpoints.rbegin()->first;
+    }
+
+    CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
+    {
+        if (!fEnabled)
+            return NULL;
+
+        const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
+
+        BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
+        {
+            const uint256& hash = i.second;
+            std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
+            if (t != mapBlockIndex.end())
+                return t->second;
+        }
+        return NULL;
+    }
+}

pool/shard006/C++/0078638_ReactorAI.cpp

@@ -0,0 +1,135 @@
+/**
+ * MaNGOS is a full featured server for World of Warcraft, supporting
+ * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
+ *
+ * Copyright (C) 2005-2022 MaNGOS <https://getmangos.eu>
+ *
+ * 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
+ *
+ * World of Warcraft, and all World of Warcraft or Warcraft art, images,
+ * and lore are copyrighted by Blizzard Entertainment, Inc.
+ */
+
+#include "ByteBuffer.h"
+#include "ReactorAI.h"
+#include "Errors.h"
+#include "Creature.h"
+#include "Map.h"
+#include "Log.h"
+
+#define REACTOR_VISIBLE_RANGE (26.46f)
+
+int
+ReactorAI::Permissible(const Creature* creature)
+{
+    if (creature->IsCivilian() || creature->IsNeutralToAll())
+    {
+        return PERMIT_BASE_REACTIVE;
+    }
+
+    return PERMIT_BASE_NO;
+}
+
+void
+ReactorAI::MoveInLineOfSight(Unit*)
+{
+}
+
+void
+ReactorAI::AttackStart(Unit* p)
+{
+    if (!p || !m_creature->CanInitiateAttack())
+    {
+        return;
+    }
+
+    if (m_creature->Attack(p, true))
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Tag unit GUID: %u (TypeId: %u) as a victim", p->GetGUIDLow(), p->GetTypeId());
+        i_victimGuid = p->GetObjectGuid();
+        m_creature->AddThreat(p);
+
+        m_creature->SetInCombatWith(p);
+        p->SetInCombatWith(m_creature);
+
+        HandleMovementOnAttackStart(p);
+    }
+}
+
+bool
+ReactorAI::IsVisible(Unit*) const
+{
+    return false;
+}
+
+void
+ReactorAI::UpdateAI(const uint32 /*time_diff*/)
+{
+    // update i_victimGuid if i_creature.getVictim() !=0 and changed
+    if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
+    {
+        return;
+    }
+
+    i_victimGuid = m_creature->getVictim()->GetObjectGuid();
+
+    DoMeleeAttackIfReady();
+}
+
+void
+ReactorAI::EnterEvadeMode()
+{
+    if (!m_creature->IsAlive())
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature stopped attacking, he is dead [guid=%u]", m_creature->GetGUIDLow());
+        m_creature->GetMotionMaster()->MovementExpired();
+        m_creature->GetMotionMaster()->MoveIdle();
+        i_victimGuid.Clear();
+        m_creature->CombatStop(true);
+        m_creature->DeleteThreatList();
+        return;
+    }
+
+    Unit* victim = m_creature->GetMap()->GetUnit(i_victimGuid);
+
+    if (!victim)
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature stopped attacking, no victim [guid=%u]", m_creature->GetGUIDLow());
+    }
+    else if (victim->HasStealthAura())
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature stopped attacking, victim is in stealth [guid=%u]", m_creature->GetGUIDLow());
+    }
+    else if (victim->IsTaxiFlying())
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature stopped attacking, victim is in flight [guid=%u]", m_creature->GetGUIDLow());
+    }
+    else
+    {
+        DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature stopped attacking, victim %s [guid=%u]", victim->IsAlive() ? "out run him" : "is dead", m_creature->GetGUIDLow());
+    }
+
+    m_creature->RemoveAllAurasOnEvade();
+    m_creature->DeleteThreatList();
+    i_victimGuid.Clear();
+    m_creature->CombatStop(true);
+    m_creature->SetLootRecipient(NULL);
+
+    // Remove ChaseMovementGenerator from MotionMaster stack list, and add HomeMovementGenerator instead
+    if (m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
+    {
+        m_creature->GetMotionMaster()->MoveTargetedHome();
+    }
+}

pool/shard006/C++/0078641_test_metro_viewer_process_host.cc

@@ -0,0 +1,50 @@
+// 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 "ash/test/test_metro_viewer_process_host.h"
+
+#include <windef.h>
+
+#include "base/logging.h"
+#include "ui/aura/remote_root_window_host_win.h"
+#include "ui/surface/accelerated_surface_win.h"
+
+namespace ash {
+namespace test {
+
+TestMetroViewerProcessHost::TestMetroViewerProcessHost(
+    base::SingleThreadTaskRunner* ipc_task_runner)
+        : MetroViewerProcessHost(ipc_task_runner), closed_unexpectedly_(false) {
+}
+
+TestMetroViewerProcessHost::~TestMetroViewerProcessHost() {
+}
+
+void TestMetroViewerProcessHost::OnChannelError() {
+  closed_unexpectedly_ = true;
+  aura::RemoteRootWindowHostWin::Instance()->Disconnected();
+}
+
+void TestMetroViewerProcessHost::OnSetTargetSurface(
+    gfx::NativeViewId target_surface) {
+  DLOG(INFO) << __FUNCTION__ << ", target_surface = " << target_surface;
+  HWND hwnd = reinterpret_cast<HWND>(target_surface);
+  aura::RemoteRootWindowHostWin::Instance()->Connected(this, hwnd);
+
+  backing_surface_.reset(new AcceleratedSurface(hwnd));
+}
+
+void TestMetroViewerProcessHost::OnOpenURL(const string16& url) {
+}
+
+void TestMetroViewerProcessHost::OnHandleSearchRequest(
+    const string16& search_string) {
+}
+
+void TestMetroViewerProcessHost::OnWindowSizeChanged(uint32 width,
+                                                     uint32 height) {
+}
+
+}  // namespace test
+}  // namespace ash

pool/shard006/C++/0078643_Firm.cpp

@@ -0,0 +1,148 @@
+/*
+  Copyright (C) 2014-2020 Sven Willner <sven.willner@pik-potsdam.de>
+                          Christian Otto <christian.otto@pik-potsdam.de>
+
+  This file is part of Acclimate.
+
+  Acclimate is free software: you can redistribute it and/or modify
+  it under the terms of the GNU Affero General Public License as
+  published by the Free Software Foundation, either version 3 of
+  the License, or (at your option) any later version.
+
+  Acclimate 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 Affero General Public License for more details.
+
+  You should have received a copy of the GNU Affero General Public License
+  along with Acclimate.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "model/Firm.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "acclimate.h"
+#include "model/CapacityManager.h"
+#include "model/EconomicAgent.h"
+#include "model/PurchasingManager.h"
+#include "model/SalesManager.h"
+#include "model/Sector.h"
+#include "model/Storage.h"
+
+namespace acclimate {
+
+Firm::Firm(id_t id_p, Sector* sector_p, Region* region_p, const Ratio& possible_overcapacity_ratio_beta_p)
+    : EconomicAgent(std::move(id_p), region_p, EconomicAgent::type_t::FIRM),
+      sector(sector_p),
+      capacity_manager(new CapacityManager(this, possible_overcapacity_ratio_beta_p)),
+      sales_manager(new SalesManager(this)) {}
+
+void Firm::produce_X() {
+    debug::assertstep(this, IterationStep::CONSUMPTION_AND_PRODUCTION);
+    production_X_ = capacity_manager->calc_production_X();
+    assert(production_X_.get_quantity() >= 0.0);
+    sector->add_production_X(production_X_);
+}
+
+void Firm::iterate_consumption_and_production() {
+    debug::assertstep(this, IterationStep::CONSUMPTION_AND_PRODUCTION);
+    produce_X();
+    for (const auto& is : input_storages) {
+        Flow used_flow_U_current = round(production_X_ * is->get_technology_coefficient_a());
+        if (production_X_.get_quantity() > 0.0) {
+            used_flow_U_current.set_price(is->get_possible_use_U_hat().get_price());
+        }
+        is->use_content_S(used_flow_U_current);
+        is->iterate_consumption_and_production();
+    }
+    sales_manager->distribute();
+}
+
+void Firm::iterate_expectation() {
+    debug::assertstep(this, IterationStep::EXPECTATION);
+    sales_manager->iterate_expectation();
+    for (const auto& is : input_storages) {
+        const FlowQuantity& desired_production =
+            std::max(sales_manager->communicated_parameters().expected_production_X.get_quantity(), sales_manager->sum_demand_requests_D().get_quantity());
+        is->set_desired_used_flow_U_tilde(round(desired_production * is->get_technology_coefficient_a()));
+    }
+}
+
+void Firm::add_initial_production_X_star(const Flow& initial_production_flow_X_star) {
+    debug::assertstep(this, IterationStep::INITIALIZATION);
+    initial_production_X_star_ += initial_production_flow_X_star;
+    production_X_ += initial_production_flow_X_star;
+    sales_manager->add_initial_demand_request_D_star(initial_production_flow_X_star);
+    sector->add_initial_production_X(initial_production_flow_X_star);
+}
+
+void Firm::subtract_initial_production_X_star(const Flow& initial_production_flow_X_star) {
+    debug::assertstep(this, IterationStep::INITIALIZATION);
+    initial_production_X_star_ -= initial_production_flow_X_star;
+    production_X_ -= initial_production_flow_X_star;
+    sales_manager->subtract_initial_demand_request_D_star(initial_production_flow_X_star);
+    sector->subtract_initial_production_X(initial_production_flow_X_star);
+}
+
+void Firm::add_initial_total_use_U_star(const Flow& initial_use_flow_U_star) {
+    debug::assertstep(this, IterationStep::INITIALIZATION);
+    initial_total_use_U_star_ += initial_use_flow_U_star;
+}
+
+void Firm::subtract_initial_total_use_U_star(const Flow& initial_use_flow_U_star) {
+    debug::assertstep(this, IterationStep::INITIALIZATION);
+    if (initial_total_use_U_star_.get_quantity() > initial_use_flow_U_star.get_quantity()) {
+        initial_total_use_U_star_ -= initial_use_flow_U_star;
+    } else {
+        initial_total_use_U_star_ = Flow(0.0);
+    }
+}
+
+void Firm::iterate_purchase() {
+    debug::assertstep(this, IterationStep::PURCHASE);
+    for (const auto& is : input_storages) {
+        is->purchasing_manager->iterate_purchase();
+    }
+}
+
+void Firm::iterate_investment() {
+    // debug::assertstep(this, IterationStep::INVESTMENT);
+    // for (const auto& is : input_storages) {
+    //     is->purchasing_manager->iterate_investment();
+    // }
+}
+
+Flow Firm::maximal_production_beta_X_star() const { return round(initial_production_X_star_ * capacity_manager->possible_overcapacity_ratio_beta); }
+
+FlowQuantity Firm::forced_maximal_production_quantity_lambda_beta_X_star() const {
+    return round(initial_production_X_star_.get_quantity() * (capacity_manager->possible_overcapacity_ratio_beta * forcing_m));
+}
+
+const BusinessConnection* Firm::self_supply_connection() const {
+    debug::assertstepnot(this, IterationStep::CONSUMPTION_AND_PRODUCTION);
+    return self_supply_connection_.get();
+}
+
+void Firm::self_supply_connection(std::shared_ptr<BusinessConnection> self_supply_connection_p) {
+    debug::assertstep(this, IterationStep::INITIALIZATION);
+    self_supply_connection_ = std::move(self_supply_connection_p);
+}
+
+const Flow& Firm::production_X() const {
+    debug::assertstepnot(this, IterationStep::CONSUMPTION_AND_PRODUCTION);
+    return production_X_;
+}
+
+void Firm::debug_print_details() const {
+    if constexpr (options::DEBUGGING) {
+        log::info(this, "X_star= ", initial_production_X_star_.get_quantity(), ":");
+        for (const auto& input_storage : input_storages) {
+            input_storage->purchasing_manager->debug_print_details();
+        }
+        sales_manager->debug_print_details();
+    }
+}
+
+}  // namespace acclimate

pool/shard006/C++/0078645_max_size.pass.cpp

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// size_type max_size() const;
+
+#include <cassert>
+#include <limits>
+#include <type_traits>
+#include <unordered_map>
+
+#include "test_allocator.h"
+#include "test_macros.h"
+
+int main()
+{
+  typedef std::pair<const int, int> KV;
+  {
+    typedef limited_allocator<KV, 10> A;
+    typedef std::unordered_multimap<int, int, std::hash<int>,
+                                    std::equal_to<int>, A>
+        C;
+    C c;
+    assert(c.max_size() <= 10);
+    LIBCPP_ASSERT(c.max_size() == 10);
+  }
+  {
+    typedef limited_allocator<KV, (size_t)-1> A;
+    typedef std::unordered_multimap<int, int, std::hash<int>,
+                                    std::equal_to<int>, A>
+        C;
+    const C::difference_type max_dist =
+        std::numeric_limits<C::difference_type>::max();
+    C c;
+    assert(c.max_size() <= max_dist);
+    LIBCPP_ASSERT(c.max_size() == max_dist);
+    }
+    {
+      typedef std::unordered_multimap<char, int> C;
+      const C::difference_type max_dist =
+          std::numeric_limits<C::difference_type>::max();
+      C c;
+      assert(c.max_size() <= max_dist);
+      assert(c.max_size() <= alloc_max_size(c.get_allocator()));
+    }
+}

pool/shard006/C++/0078646_gist.cpp

@@ -0,0 +1,120 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 10:43:31 +0200 (to, 25 aug 2011) $ by $Author: tack $
+ *     $Revision: 12352 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ * 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 <QtGui>
+
+#include <gecode/gist.hh>
+#include <gecode/gist/textoutput.hh>
+#include <gecode/gist/mainwindow.hh>
+#include <gecode/gist/stopbrancher.hh>
+
+namespace Gecode { namespace Gist {
+
+  std::string
+  Inspector::name(void) { return "Inspector"; }
+  
+  void
+  Inspector::finalize(void) {}
+  
+  Inspector::~Inspector(void) {}
+
+  std::string
+  Comparator::name(void) { return "Comparator"; }
+  
+  void
+  Comparator::finalize(void) {}
+  
+  Comparator::~Comparator(void) {}
+    
+  TextOutput::TextOutput(const std::string& name)
+    : t(NULL), n(name) {}
+  
+  void
+  TextOutput::finalize(void) {
+    delete t;
+    t = NULL;
+  }
+  
+  TextOutput::~TextOutput(void) {
+    delete t;
+  }
+
+  std::string
+  TextOutput::name(void) { return n; }
+  
+  void
+  TextOutput::init(void) {
+    if (t == NULL) {
+      t = new TextOutputI(n);
+    }
+    t->setVisible(true);
+  }
+
+  std::ostream&
+  TextOutput::getStream(void) {
+    return t->getStream();
+  }
+  
+  void
+  TextOutput::flush(void) {
+    t->flush();
+  }
+  
+  void
+  TextOutput::addHtml(const char* s) {
+    t->insertHtml(s);
+  }
+
+  const Options Options::def;
+  
+  int
+  explore(Space* root, bool bab, const Options& opt) {
+    char argv0='\0'; char* argv1=&argv0;
+    int argc=0;
+    QApplication app(argc, &argv1);
+    GistMainWindow mw(root, bab, opt);
+    return app.exec();
+  }
+
+  void
+  stopBranch(Space& home) {
+    StopBrancher::post(home);
+  }
+
+}}
+
+// STATISTICS: gist-any

pool/shard006/C++/0078662_lock_impl_unittest.cc

@@ -0,0 +1,199 @@
+// Copyright (c) 2018 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 "chromeos/components/nearby/lock_impl.h"
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/containers/flat_set.h"
+#include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
+#include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
+#include "base/test/gtest_util.h"
+#include "base/test/task_environment.h"
+#include "base/test/test_timeouts.h"
+#include "base/threading/platform_thread.h"
+#include "base/unguessable_token.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace nearby {
+
+class LockImplTest : public testing::Test {
+ protected:
+  LockImplTest()
+      : lock_(std::make_unique<LockImpl>()),
+        different_thread_task_runner_(
+            base::ThreadPool::CreateSingleThreadTaskRunner(
+                {base::MayBlock()})) {}
+
+  // testing::Test
+  void SetUp() override {
+    // |different_thread_task_runner_| is expected to run on a different thread
+    // than the main test thread.
+    EXPECT_FALSE(different_thread_task_runner_->BelongsToCurrentThread());
+  }
+
+  void TearDown() override {
+    // Releases the test thread's ownership of |lock_|.
+    int times_to_unlock;
+    {
+      base::AutoLock al(lock_->bookkeeping_lock_);
+      times_to_unlock = lock_->num_acquisitions_;
+    }
+    for (int i = 0; i < times_to_unlock; ++i)
+      lock_->unlock();
+
+    // Makes sure that outstanding LockAndUnlockFromDifferentThread() tasks in
+    // |different_thread_task_runner_| finish running after the test thread
+    // relinquishes its ownership of |lock_|.
+    task_environment_.RunUntilIdle();
+
+    base::AutoLock al(lock_->bookkeeping_lock_);
+    EXPECT_EQ(0u, lock_->num_acquisitions_);
+    EXPECT_EQ(base::kInvalidThreadId, lock_->owning_thread_id_);
+  }
+
+  void PostLockAndUnlockFromDifferentThread(
+      const base::UnguessableToken& attempt_id) {
+    different_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&LockImplTest::LockAndUnlockFromDifferentThread,
+                       base::Unretained(this), attempt_id));
+  }
+
+  // Invoked whenever attempting to verify that a parallel task has indeed
+  // blocked, since there's no way to deterministically find out if that task
+  // will ever unblock.
+  void TinyTimeout() {
+    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  }
+
+  bool HasSuccessfullyLockedWithAttemptId(
+      const base::UnguessableToken& attempt_id) {
+    lock_->lock();
+    bool contains_key = base::Contains(successful_lock_attempts_, attempt_id);
+    lock_->unlock();
+    return contains_key;
+  }
+
+  location::nearby::Lock* lock() { return lock_.get(); }
+
+  base::test::TaskEnvironment task_environment_;
+
+ private:
+  // Only meant to be posted via PostLockAndUnlockFromDifferentThread() on
+  // |different_thread_task_runner_|.
+  //
+  // This method will only insert |attempt_id| into |successful_lock_attempts_|
+  // if it succeeds in acquiring |lock_|. It will also immediately unlock()
+  // after doing so because unlock() may only be called from the same thread
+  // that originally called lock().
+  void LockAndUnlockFromDifferentThread(
+      const base::UnguessableToken& attempt_id) {
+    lock_->lock();
+    successful_lock_attempts_.insert(attempt_id);
+    lock_->unlock();
+  }
+
+  std::unique_ptr<LockImpl> lock_;
+  scoped_refptr<base::SingleThreadTaskRunner> different_thread_task_runner_;
+  base::flat_set<base::UnguessableToken> successful_lock_attempts_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockImplTest);
+};
+
+TEST_F(LockImplTest, LockOnce_UnlockOnce) {
+  lock()->lock();
+  lock()->unlock();
+}
+
+TEST_F(LockImplTest, LockThrice_UnlockThrice) {
+  lock()->lock();
+  lock()->lock();
+  lock()->lock();
+  lock()->unlock();
+  lock()->unlock();
+  lock()->unlock();
+}
+
+TEST_F(LockImplTest,
+       LockOnce_DisallowRelockingFromDifferentThreadUntilCurrentThreadUnlocks) {
+  // Lock on current thread.
+  lock()->lock();
+
+  // Try to lock again, but on different thread.
+  base::UnguessableToken attempt_id = base::UnguessableToken::Create();
+  PostLockAndUnlockFromDifferentThread(attempt_id);
+
+  // Wait for a little, then check to see if the lock attempt failed.
+  TinyTimeout();
+  EXPECT_FALSE(HasSuccessfullyLockedWithAttemptId(attempt_id));
+
+  // Outstanding lock attempt succeed after unlocking from current thread.
+  lock()->unlock();
+  task_environment_.RunUntilIdle();
+  EXPECT_TRUE(HasSuccessfullyLockedWithAttemptId(attempt_id));
+}
+
+TEST_F(
+    LockImplTest,
+    LockThrice_DisallowRelockingFromDifferentThreadUntilCurrentThreadUnlocks) {
+  // Lock on current thread.
+  lock()->lock();
+  lock()->lock();
+  lock()->lock();
+
+  // Try to lock again, but on different thread.
+  base::UnguessableToken attempt_id = base::UnguessableToken::Create();
+  PostLockAndUnlockFromDifferentThread(attempt_id);
+
+  // Wait for a little, then check to see if the lock attempt failed.
+  TinyTimeout();
+  EXPECT_FALSE(HasSuccessfullyLockedWithAttemptId(attempt_id));
+
+  // Outstanding lock attempt succeed after unlocking from current thread.
+  lock()->unlock();
+  lock()->unlock();
+  lock()->unlock();
+  task_environment_.RunUntilIdle();
+  EXPECT_TRUE(HasSuccessfullyLockedWithAttemptId(attempt_id));
+}
+
+TEST_F(LockImplTest, InterweavedLocking) {
+  base::UnguessableToken attempt_id1 = base::UnguessableToken::Create();
+  base::UnguessableToken attempt_id2 = base::UnguessableToken::Create();
+  base::UnguessableToken attempt_id3 = base::UnguessableToken::Create();
+
+  lock()->lock();
+  PostLockAndUnlockFromDifferentThread(attempt_id1);
+  lock()->lock();
+  PostLockAndUnlockFromDifferentThread(attempt_id2);
+  lock()->lock();
+  PostLockAndUnlockFromDifferentThread(attempt_id3);
+
+  TinyTimeout();
+  EXPECT_FALSE(HasSuccessfullyLockedWithAttemptId(attempt_id1));
+  EXPECT_FALSE(HasSuccessfullyLockedWithAttemptId(attempt_id2));
+  EXPECT_FALSE(HasSuccessfullyLockedWithAttemptId(attempt_id3));
+
+  lock()->unlock();
+  lock()->unlock();
+  lock()->unlock();
+  task_environment_.RunUntilIdle();
+  EXPECT_TRUE(HasSuccessfullyLockedWithAttemptId(attempt_id1));
+  EXPECT_TRUE(HasSuccessfullyLockedWithAttemptId(attempt_id2));
+  EXPECT_TRUE(HasSuccessfullyLockedWithAttemptId(attempt_id3));
+}
+
+TEST_F(LockImplTest, CannotUnlockBeforeAnyLocks) {
+  EXPECT_DCHECK_DEATH(lock()->unlock());
+}
+
+}  // namespace nearby
+
+}  // namespace chromeos

pool/shard006/C++/0078666_lanRouter.cc

@@ -0,0 +1,129 @@
+/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
+
+/*
+ * Copyright (C) 1998 by the University of Southern California
+ * $Id: lanRouter.cc,v 1.10 2005/08/25 18:58:07 johnh Exp $
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *
+ * The copyright of this module includes the following
+ * linking-with-specific-other-licenses addition:
+ *
+ * In addition, as a special exception, the copyright holders of
+ * this module give you permission to combine (via static or
+ * dynamic linking) this module with free software programs or
+ * libraries that are released under the GNU LGPL and with code
+ * included in the standard release of ns-2 under the Apache 2.0
+ * license or under otherwise-compatible licenses with advertising
+ * requirements (or modified versions of such code, with unchanged
+ * license).  You may copy and distribute such a system following the
+ * terms of the GNU GPL for this module and the licenses of the
+ * other code concerned, provided that you include the source code of
+ * that other code when and as the GNU GPL requires distribution of
+ * source code.
+ *
+ * Note that people who make modified versions of this module
+ * are not obligated to grant this special exception for their
+ * modified versions; it is their choice whether to do so.  The GNU
+ * General Public License gives permission to release a modified
+ * version without this exception; this exception also makes it
+ * possible to release a modified version which carries forward this
+ * exception.
+ *
+ */
+
+#ifndef lint
+static const char rcsid[] =
+    "@(#) $Header: /usr/src/mash/repository/vint/ns-2/lanRouter.cc";
+#endif
+
+#include <tcl.h>
+#include "lanRouter.h"
+#include "address.h"
+#include "ip.h"
+
+static class LanRouterClass : public TclClass {
+public:
+	LanRouterClass() : TclClass("LanRouter") {}
+	TclObject* create(int, const char*const*) {
+		return (new LanRouter());
+	}
+} class_mac;
+
+int LanRouter::next_hop(Packet *p) {
+ 	if (switch_ && switch_->classify(p)==1) {
+		return -1;
+ 	}
+	if (!routelogic_) return -1;
+
+	hdr_ip* iph= hdr_ip::access(p);
+	char* adst= Address::instance().print_nodeaddr(iph->daddr());
+	int next_hopIP;
+
+	if (enableHrouting_) {
+		char* bdst;
+
+		routelogic_->lookup_hier(lanaddr_, adst, next_hopIP);
+		// hacking: get rid of the last "."
+		bdst = Address::instance().print_nodeaddr(next_hopIP);
+// 		bdst[strlen(bdst)-1] = '\0';
+		Tcl &tcl = Tcl::instance();
+		tcl.evalf("[Simulator instance] get-node-id-by-addr %s", bdst);
+		sscanf(tcl.result(), "%d", &next_hopIP);
+		delete [] bdst;
+	} else {
+		routelogic_->lookup_flat(lanaddr_, adst, next_hopIP);
+	}
+	delete [] adst;
+
+	return next_hopIP;
+}
+int LanRouter::command(int argc, const char*const* argv)
+{
+	// Tcl& tcl = Tcl::instance();
+	if (argc == 3) {
+		// cmd lanaddr <addr>
+		if (strcmp(argv[1], "lanaddr") == 0) {
+			strcpy(lanaddr_, argv[2]);
+			return (TCL_OK);
+		}
+		// cmd routing hier|flat
+		if (strcmp(argv[1], "routing") == 0) {
+			if (strcmp(argv[2], "hier")==0)
+				enableHrouting_= true;
+			else if (strcmp(argv[2], "flat")==0)
+				enableHrouting_= false;
+			else return (TCL_ERROR);
+			return (TCL_OK);
+		}
+		// cmd switch <switch>
+		if (strcmp(argv[1], "switch") == 0) {
+			switch_ = (Classifier*) TclObject::lookup(argv[2]);
+			return (TCL_OK);
+		}
+		// cmd routelogic <routelogic>
+		if (strcmp(argv[1], "routelogic") == 0) {
+			routelogic_ = (RouteLogic*) TclObject::lookup(argv[2]);
+			return (TCL_OK);
+		}
+	}
+	return NsObject::command(argc, argv);
+}
+
+
+
+
+
+

pool/shard006/C++/0078667_EventFactory.cpp

@@ -0,0 +1,54 @@
+/* Siconos is a program dedicated to modeling, simulation and control
+ * of non smooth dynamical systems.
+ *
+ * Copyright 2020 INRIA.
+ *
+ * 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.
+*/
+
+#include "EventFactory.hpp"
+#include "SiconosException.hpp"
+#include <iostream>
+
+
+
+namespace EventFactory
+{
+
+Registry& Registry::get()
+{
+  static Registry instance;
+  return instance;
+}
+
+void Registry::add(int type, object_creator creator)
+{
+  factory_map[type] = creator;
+}
+
+SP::Event Registry::instantiate(double time, int type)
+{
+  MapFactoryIt it = factory_map.find(type) ;
+
+  if(it == factory_map.end())
+    THROW_EXCEPTION("Registry::instantiate (EventFactory) failed, no class with id: " + std::to_string(type));
+
+  return (it->second)(time, type) ; // run our factory
+}
+
+Registration::Registration(int type, object_creator creator)
+{
+  Registry::get().add(type, creator) ;
+}
+
+}

pool/shard006/C++/0078671_testing_cgebrd.cpp

@@ -0,0 +1,202 @@
+/*
+    -- MAGMA (version 1.5.0-beta3) --
+       Univ. of Tennessee, Knoxville
+       Univ. of California, Berkeley
+       Univ. of Colorado, Denver
+       @date July 2014
+
+       @generated from testing_zgebrd.cpp normal z -> c, Fri Jul 18 17:34:25 2014
+
+*/
+
+// includes, system
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <cuda_runtime_api.h>
+#include <cublas.h>
+
+// includes, project
+#include "flops.h"
+#include "magma.h"
+#include "magma_lapack.h"
+#include "testings.h"
+
+#define PRECISION_c
+
+/* ////////////////////////////////////////////////////////////////////////////
+   -- Testing cgebrd
+*/
+int main( int argc, char** argv)
+{
+    TESTING_INIT();
+
+    real_Double_t    gflops, gpu_perf, gpu_time, cpu_perf, cpu_time;
+    magmaFloatComplex *h_A, *h_Q, *h_PT, *h_work;
+    magmaFloatComplex *taup, *tauq;
+    float      *diag, *offdiag;
+    float      eps, result[3] = {0., 0., 0.};
+    magma_int_t M, N, n2, lda, lhwork, info, minmn, nb;
+    magma_int_t ione     = 1;
+    magma_int_t ISEED[4] = {0,0,0,1};
+
+    eps = lapackf77_slamch( "E" );
+    magma_int_t status = 0;
+
+    magma_opts opts;
+    parse_opts( argc, argv, &opts );
+
+    float tol = opts.tolerance * lapackf77_slamch("E");
+    
+    printf("    M     N   CPU GFlop/s (sec)   GPU GFlop/s (sec)   |A-QBP'|/N|A|  |I-QQ'|/N  |I-PP'|/N\n");
+    printf("=========================================================================================\n");
+    for( int itest = 0; itest < opts.ntest; ++itest ) {
+        for( int iter = 0; iter < opts.niter; ++iter ) {
+            M = opts.msize[itest];
+            N = opts.nsize[itest];
+            minmn  = min(M, N);
+            nb     = magma_get_cgebrd_nb(N);
+            lda    = M;
+            n2     = lda*N;
+            lhwork = (M + N)*nb;
+            gflops = FLOPS_CGEBRD( M, N ) / 1e9;
+
+            TESTING_MALLOC_CPU( h_A,     magmaFloatComplex, lda*N );
+            TESTING_MALLOC_CPU( tauq,    magmaFloatComplex, minmn );
+            TESTING_MALLOC_CPU( taup,    magmaFloatComplex, minmn );
+            TESTING_MALLOC_CPU( diag,    float, minmn   );
+            TESTING_MALLOC_CPU( offdiag, float, minmn-1 );
+            
+            TESTING_MALLOC_PIN( h_Q,     magmaFloatComplex, lda*N  );
+            TESTING_MALLOC_PIN( h_work,  magmaFloatComplex, lhwork );
+            
+            /* Initialize the matrices */
+            lapackf77_clarnv( &ione, ISEED, &n2, h_A );
+            lapackf77_clacpy( MagmaUpperLowerStr, &M, &N, h_A, &lda, h_Q, &lda );
+            
+            /* ====================================================================
+               Performs operation using MAGMA
+               =================================================================== */
+            gpu_time = magma_wtime();
+            magma_cgebrd( M, N, h_Q, lda,
+                          diag, offdiag, tauq, taup,
+                          h_work, lhwork, &info);
+            gpu_time = magma_wtime() - gpu_time;
+            gpu_perf = gflops / gpu_time;
+            if (info != 0)
+                printf("magma_cgebrd returned error %d: %s.\n",
+                       (int) info, magma_strerror( info ));
+            
+            /* =====================================================================
+               Check the factorization
+               =================================================================== */
+            if ( opts.check ) {
+                // cungbr prefers minmn*NB
+                // cbdt01 needs M+N
+                // cunt01 prefers minmn*(minmn+1) to check Q and P
+                magma_int_t lwork_err;
+                magmaFloatComplex *h_work_err;
+                lwork_err = max( minmn * nb, M+N );
+                lwork_err = max( lwork_err, minmn*(minmn+1) );
+                TESTING_MALLOC_CPU( h_PT,       magmaFloatComplex, lda*N     );
+                TESTING_MALLOC_CPU( h_work_err, magmaFloatComplex, lwork_err );
+                
+                // cbdt01 needs M
+                // cunt01 needs minmn
+                #if defined(PRECISION_z) || defined(PRECISION_c)
+                float *rwork_err;
+                TESTING_MALLOC_CPU( rwork_err, float, M );
+                #endif
+
+                lapackf77_clacpy(MagmaUpperLowerStr, &M, &N, h_Q, &lda, h_PT, &lda);
+                
+                // generate Q & P'
+                lapackf77_cungbr("Q", &M, &minmn, &N, h_Q,  &lda, tauq, h_work_err, &lwork_err, &info);
+                if (info != 0)
+                    printf("lapackf77_cungbr #1 returned error %d: %s.\n",
+                           (int) info, magma_strerror( info ));
+                lapackf77_cungbr("P", &minmn, &N, &M, h_PT, &lda, taup, h_work_err, &lwork_err, &info);
+                if (info != 0)
+                    printf("lapackf77_cungbr #2 returned error %d: %s.\n",
+                           (int) info, magma_strerror( info ));
+                
+                // Test 1:  Check the decomposition A := Q * B * PT
+                //      2:  Check the orthogonality of Q
+                //      3:  Check the orthogonality of PT
+                #if defined(PRECISION_z) || defined(PRECISION_c)
+                lapackf77_cbdt01(&M, &N, &ione,
+                                 h_A, &lda, h_Q, &lda,
+                                 diag, offdiag, h_PT, &lda,
+                                 h_work_err, rwork_err, &result[0]);
+                lapackf77_cunt01("Columns", &M, &minmn, h_Q,  &lda, h_work_err, &lwork_err, rwork_err, &result[1]);
+                lapackf77_cunt01("Rows",    &minmn, &N, h_PT, &lda, h_work_err, &lwork_err, rwork_err, &result[2]);
+                #else
+                lapackf77_cbdt01(&M, &N, &ione,
+                                 h_A, &lda, h_Q, &lda,
+                                 diag, offdiag, h_PT, &lda,
+                                 h_work_err, &result[0]);
+                lapackf77_cunt01("Columns", &M, &minmn, h_Q,  &lda, h_work_err, &lwork_err, &result[1]);
+                lapackf77_cunt01("Rows",    &minmn, &N, h_PT, &lda, h_work_err, &lwork_err, &result[2]);
+                #endif
+                
+                TESTING_FREE_CPU( h_PT );
+                TESTING_FREE_CPU( h_work_err );
+                #if defined(PRECISION_z) || defined(PRECISION_c)
+                TESTING_FREE_CPU( rwork_err );
+                #endif
+            }
+            
+            /* =====================================================================
+               Performs operation using LAPACK
+               =================================================================== */
+            if ( opts.lapack ) {
+                cpu_time = magma_wtime();
+                lapackf77_cgebrd(&M, &N, h_A, &lda,
+                                 diag, offdiag, tauq, taup,
+                                 h_work, &lhwork, &info);
+                cpu_time = magma_wtime() - cpu_time;
+                cpu_perf = gflops / cpu_time;
+                if (info != 0)
+                    printf("lapackf77_cgebrd returned error %d: %s.\n",
+                           (int) info, magma_strerror( info ));
+            }
+            
+            /* =====================================================================
+               Print performance and error.
+               =================================================================== */
+            if ( opts.lapack ) {
+                printf("%5d %5d   %7.2f (%7.2f)   %7.2f (%7.2f)",
+                       (int) M, (int) N, cpu_perf, cpu_time, gpu_perf, gpu_time );
+            }
+            else {
+                printf("%5d %5d     ---   (  ---  )   %7.2f (%7.2f)",
+                       (int) M, (int) N, gpu_perf, gpu_time );
+            }
+            if ( opts.check ) {
+                printf("   %8.2e       %8.2e   %8.2e   %s\n",
+                       result[0]*eps, result[1]*eps, result[2]*eps,
+                       (result[0]*eps < tol && result[1]*eps < tol && result[2]*eps < tol ? "ok" : "failed") );
+                status += ! (result[0]*eps < tol && result[1]*eps < tol && result[2]*eps < tol);
+            } else {
+                printf("     ---            --- \n");
+            }
+            
+            TESTING_FREE_CPU( h_A     );
+            TESTING_FREE_CPU( tauq    );
+            TESTING_FREE_CPU( taup    );
+            TESTING_FREE_CPU( diag    );
+            TESTING_FREE_CPU( offdiag );
+            
+            TESTING_FREE_PIN( h_Q    );
+            TESTING_FREE_PIN( h_work );
+            fflush( stdout );
+        }
+        if ( opts.niter > 1 ) {
+            printf( "\n" );
+        }
+    }
+
+    TESTING_FINALIZE();
+    return status;
+}

pool/shard006/C++/0078672_GraphNodeView.cpp

@@ -0,0 +1,228 @@
+#include "stdafx.h"
+
+#ifndef GRAPHNODEVIEW_H
+#include "GraphNodeView.h"
+#endif
+#ifndef GRAPHEDGEVIEW_H
+#include "stdafx.h"
+#include "GraphEdgeView.h"
+#endif
+#ifndef PLANSTEPEX_H
+#include "PlanStepEx.h"
+#endif
+#include "OlcbpPlanNodeData.h"
+
+using namespace IStrategizer;
+using namespace std;
+
+GraphNodeView::GraphNodeView(PlanStepEx* pPlanStep, ConstOlcbpPlanNodeDataPtr pNodeData, QMenu *pContextMeun, QGraphicsItem *pParent /* = 0 */) :
+QGraphicsRectItem(pParent),
+m_modelId(pPlanStep->Id()),
+m_isActive(false),
+m_isOpen(false),
+m_pNodeModel(pPlanStep),
+m_pContextMenu(pContextMeun),
+m_pNodeData(pNodeData),
+m_SatisfyingGoalId(IOlcbpPlan::NullNodeID)
+{
+	_ASSERTE(m_pNodeModel);
+
+	m_nodeTxt = QString::fromStdString(pPlanStep->ToString(true));
+	m_tooltipTxt[0] = 0,
+
+		m_style = GetStyle();
+
+	setBrush(m_style.BackgroundBrush);
+	setPen(m_style.BorderPen);
+
+	// Measure text width and set the node width accordingly with small padding
+	QFontMetrics fontMetric(m_style.TxtFont);
+
+	m_nodeHeight = fontMetric.height() + 40;
+	m_nodeWidth = fontMetric.width(m_nodeTxt) + 20;
+
+	setFlag(QGraphicsItem::ItemIsSelectable);
+	setFlag(QGraphicsItem::ItemIsMovable);
+	setFlag(QGraphicsItem::ItemSendsGeometryChanges);
+
+	m_nodeToString = m_pNodeModel->ToString().c_str();
+	m_isGoal = BELONG(GoalType, m_pNodeModel->StepTypeId());
+
+	if (m_pNodeData != nullptr)
+		m_SatisfyingGoalId = m_pNodeData->SatisfyingGoal;
+
+	if (m_pNodeData == nullptr)
+		setToolTip(QString::fromLocal8Bit(m_pNodeModel->ToString().c_str()));
+}
+//----------------------------------------------------------------------------------------------
+void GraphNodeView::AddEdge(GraphEdgeView* p_edge)
+{
+	m_edges.append(p_edge);
+}
+//----------------------------------------------------------------------------------------------
+void GraphNodeView::RemoveEdge(GraphEdgeView* p_edge)
+{
+	QList<GraphEdgeView*>::iterator where = find(m_edges.begin(), m_edges.end(), p_edge);
+
+	if (where != m_edges.end())
+		m_edges.erase(where);
+}
+//----------------------------------------------------------------------------------------------
+QList<GraphEdgeView*> GraphNodeView::Disconnect()
+{
+	GraphNodeView *other = NULL;
+	QList<GraphEdgeView*> edges(m_edges);
+
+	foreach(GraphEdgeView* edge, edges)
+	{
+		if (edge->StartNode() != this)
+			other = edge->StartNode();
+		else
+			other = edge->EndNode();
+
+		other->RemoveEdge(edge);
+		this->RemoveEdge(edge);
+	}
+
+	return edges;
+}
+//----------------------------------------------------------------------------------------------
+QVariant GraphNodeView::itemChange(GraphicsItemChange change,
+	const QVariant &value)
+{
+	if (change == QGraphicsItem::ItemPositionChange)
+	{
+		foreach(GraphEdgeView *edge, m_edges)
+		{
+			edge->UpdatePosition();
+		}
+	}
+
+	return value;
+}
+//----------------------------------------------------------------------------------------------
+void GraphNodeView::paint(QPainter *p_painter, const QStyleOptionGraphicsItem *p_option, QWidget *p_widget)
+{
+	QGraphicsRectItem::paint(p_painter, p_option, p_widget);
+
+	m_style = GetStyle();
+
+	setBrush(m_style.BackgroundBrush);
+	setPen(m_style.BorderPen);
+
+	QTextOption textOption;
+	textOption.setAlignment(Qt::AlignCenter);
+
+	p_painter->setFont(m_style.TxtFont);
+	p_painter->setPen(m_style.TxtPen);
+
+	// Measure text width and set the node width accordingly with small padding
+	QFontMetrics fontMetric(m_style.TxtFont);
+
+	m_nodeHeight = fontMetric.height() + 20;
+	m_nodeWidth = fontMetric.width(m_nodeTxt) + 20;
+
+	// Call setRect ONLY in case the node dimensions changed, if it is called each paint
+	// it will cause infinite loop (and lead to stack overflow) because setRect always
+	// case the node to repaint
+	if (rect().width() != m_nodeWidth || rect().height() != m_nodeHeight)
+		setRect(0, 0, m_nodeWidth, m_nodeHeight);
+
+	setToolTip(QString::fromLocal8Bit(m_tooltipTxt));
+
+	p_painter->drawText(this->rect(), m_nodeTxt, textOption);
+}
+//----------------------------------------------------------------------------------------------
+void GraphNodeView::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
+{
+	event->accept();
+	scene()->clearSelection();
+	setSelected(true);
+	if (m_pContextMenu != NULL)
+		m_pContextMenu->exec(event->screenPos());
+}
+//////////////////////////////////////////////////////////////////////////
+GraphNodeView::NodeStyle GraphNodeView::GetStyle()
+{
+	NodeStyle style;
+
+	Qt::GlobalColor bgBrushColor = Qt::white;
+	Qt::GlobalColor txtPenColor = Qt::black;
+	Qt::GlobalColor borderColor = Qt::black;
+	auto fillPattern = Qt::SolidPattern;
+
+	switch (m_state)
+	{
+	case ESTATE_Failed:
+		bgBrushColor = Qt::red;
+		break;
+	case ESTATE_Succeeded:
+		bgBrushColor = Qt::green;
+		break;
+	case ESTATE_NotPrepared:
+		if (m_isGoal)
+		{
+			if (!m_isOpen)
+			{
+				bgBrushColor = Qt::blue;
+				txtPenColor = Qt::white;
+			}
+			else
+				bgBrushColor = Qt::lightGray;
+		}
+		else
+			bgBrushColor = Qt::lightGray;
+		break;
+	case ESTATE_Pending:
+		bgBrushColor = Qt::yellow;
+		break;
+	case ESTATE_Executing:
+		bgBrushColor = Qt::blue;
+		txtPenColor = Qt::white;
+		break;
+	default:
+		bgBrushColor = Qt::white;
+		break;
+	}
+
+	style.BackgroundBrush = QBrush(bgBrushColor, fillPattern);
+	style.BorderPen = QPen(QColor(borderColor));
+	style.TxtPen = QPen(QColor(txtPenColor));
+
+	if (m_isGoal)
+	{
+		style.TxtFont.setBold(true);
+		style.TxtFont.setPixelSize(26);
+		style.BorderPen.setWidth(2);
+
+		if (m_isActive)
+		{
+			style.TxtFont.setItalic(true);
+			style.TxtFont.setUnderline(true);
+		}
+	}
+	else
+	{
+		style.TxtFont.setPixelSize(22);
+		style.BorderPen.setWidth(1);
+	}
+
+	return style;
+}
+//////////////////////////////////////////////////////////////////////////
+void GraphNodeView::OnUpdate()
+{
+	m_state = m_pNodeModel->GetState();
+
+	if (m_pNodeData != nullptr)
+	{
+		m_isOpen = m_pNodeData->IsOpen;
+
+		sprintf_s(m_tooltipTxt, "%s: O?%d, SG:%d, PC:%d, CC:%d",
+			m_nodeToString.c_str(),
+			m_pNodeData->IsOpen,
+			m_pNodeData->SatisfyingGoal,
+			m_pNodeData->WaitOnParentsCount,
+			m_pNodeData->WaitOnChildrenCount);
+	}
+}

pool/shard006/C++/0078678_benchmarkudf.cc

@@ -0,0 +1,140 @@
+/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Copyright (C) 2008 MySQL AB
+ *
+ * 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; version 2 of the License.
+ *
+ * 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 St, Fifth Floor, Boston, MA  02110-1301  USA 
+ */
+
+#include <config.h>
+#include <drizzled/error.h>
+#include <drizzled/internal/m_string.h>
+#include <drizzled/plugin/function.h>
+#include <drizzled/session.h>
+
+using namespace std;
+using namespace drizzled;
+
+class BenchmarkFunction :public Item_int_func
+{
+public:
+  BenchmarkFunction() :Item_int_func() {}
+  int64_t val_int();
+  virtual void print(String *str);
+
+  const char *func_name() const
+  { 
+    return "benchmark"; 
+  }
+
+  void fix_length_and_dec()
+  { 
+    max_length= 1; 
+    maybe_null= false;
+  }
+
+  bool check_argument_count(int n)
+  { 
+    return (n == 2); 
+  }
+};
+
+
+/* This function is just used to test speed of different functions */
+int64_t BenchmarkFunction::val_int()
+{
+  assert(fixed == true);
+
+  char buff[MAX_FIELD_WIDTH];
+  String tmp(buff,sizeof(buff), &my_charset_bin);
+  type::Decimal tmp_decimal;
+  uint64_t loop_count;
+
+  loop_count= (uint64_t) args[0]->val_int();
+
+  if (args[0]->null_value ||
+      (args[0]->unsigned_flag == false && (((int64_t) loop_count) < 0)))
+  {
+    if (args[0]->null_value == false)
+    {
+      internal::int64_t10_to_str((int64_t)loop_count, buff, -10);
+      push_warning_printf(&getSession(), DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+                          ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
+                          "count", buff, "benchmark");
+    }
+
+    null_value= true;
+    return 0;
+  }
+
+  null_value= false;
+
+  uint64_t loop;
+  for (loop= 0 ; loop < loop_count && not getSession().getKilled(); loop++)
+  {
+    switch (args[1]->result_type()) 
+    {
+    case REAL_RESULT:
+      (void) args[1]->val_real();
+      break;
+    case INT_RESULT:
+      (void) args[1]->val_int();
+      break;
+    case STRING_RESULT:
+      (void) args[1]->val_str(&tmp);
+      break;
+    case DECIMAL_RESULT:
+      (void) args[1]->val_decimal(&tmp_decimal);
+      break;
+    case ROW_RESULT:
+    default:
+      // This case should never be chosen
+      assert(0);
+      return 0;
+    }
+  }
+  return 0;
+}
+
+void BenchmarkFunction::print(String *str)
+{
+  str->append(STRING_WITH_LEN("benchmark("));
+  args[0]->print(str);
+  str->append(',');
+  args[1]->print(str);
+  str->append(')');
+}
+
+plugin::Create_function<BenchmarkFunction> *benchmarkudf= NULL;
+
+static int initialize(module::Context &context)
+{
+  benchmarkudf= new plugin::Create_function<BenchmarkFunction>("benchmark");
+  context.add(benchmarkudf);
+  return 0;
+}
+
+DRIZZLE_DECLARE_PLUGIN
+{
+  DRIZZLE_VERSION_ID,
+  "benchmark",
+  "1.0",
+  "Devananda van der Veen",
+  "Measure time for repeated calls to a function.",
+  PLUGIN_LICENSE_GPL,
+  initialize, /* Plugin Init */
+  NULL,   /* depends */
+  NULL    /* config options */
+}
+DRIZZLE_DECLARE_PLUGIN_END;

pool/shard006/C++/0078679_skinned_mesh.cpp

@@ -0,0 +1,89 @@
+#include <mesh_converter/mesh_converter.hpp>
+
+#include <zombye/rendering/rendering_system.hpp>
+#include <zombye/rendering/skinned_mesh.hpp>
+#include <zombye/utils/logger.hpp>
+
+#include <glm/gtx/string_cast.hpp>
+
+namespace zombye {
+    skinned_mesh::skinned_mesh(rendering_system& rendering_system, const std::vector<char>& source, const std::string& file_name) noexcept
+    : vbo_{0, GL_STATIC_DRAW}, ibo_{0, GL_STATIC_DRAW}, parallax_mapping_{false} {
+        auto data_ptr = source.data();
+
+        auto head = *reinterpret_cast<const header*>(data_ptr);
+        if (head.magic != 0x31424D5A) {
+            throw std::runtime_error(file_name + " is not an zombye mesh file");
+        }
+
+        parallax_mapping_ = head.parallax_mapping;
+
+        auto vertex_size = head.vertex_count * sizeof(skinned_vertex);
+        auto index_size = head.index_count * sizeof(uint32_t);
+        auto size = sizeof(header)
+            + vertex_size
+            + index_size
+            + head.submesh_count * sizeof(devtools::submesh);
+
+        if (size != source.size()) {
+            throw std::runtime_error(file_name + " has not the apropriate size. expected size: "
+                + std::to_string(source.size()) + " calculated size: " + std::to_string(size));
+        }
+        data_ptr += sizeof(header);
+
+        vbo_.data(vertex_size, data_ptr);
+        data_ptr += vertex_size;
+
+        ibo_.data(index_size, data_ptr);
+        data_ptr += index_size;
+
+        for (auto i = 0; i < head.submesh_count; ++i) {
+            submesh s;
+
+            s.index_count = *reinterpret_cast<const uint64_t*>(data_ptr);
+            data_ptr += sizeof(uint64_t);
+            s.offset = *reinterpret_cast<const uint64_t*>(data_ptr);
+            data_ptr += sizeof(uint64_t);
+
+            auto texture_id = *reinterpret_cast<const uint64_t*>(data_ptr);
+            auto texture_name = std::to_string(texture_id) + ".dds";
+            s.diffuse = rendering_system.texture_manager().load("texture/" + texture_name);
+            if (!s.diffuse) {
+                throw std::runtime_error("could not load texure " + texture_name);
+            }
+            data_ptr += sizeof(uint64_t);
+
+            texture_id = *reinterpret_cast<const uint64_t*>(data_ptr);
+            texture_name = std::to_string(texture_id) + ".dds";
+            s.normal = rendering_system.texture_manager().load("texture/" + texture_name);
+            if (!s.normal) {
+                throw std::runtime_error("could not load texure " + texture_name);
+            }
+            data_ptr += sizeof(uint64_t);
+
+            texture_id = *reinterpret_cast<const uint64_t*>(data_ptr);
+            texture_name = std::to_string(texture_id) + ".dds";
+            s.material = rendering_system.texture_manager().load("texture/" + texture_name);
+            if (!s.material) {
+                throw std::runtime_error("could not load texure " + texture_name);
+            }
+            data_ptr += sizeof(uint64_t);
+
+            submeshes_.emplace_back(s);
+        }
+
+        vao_.bind_index_buffer(ibo_);
+        rendering_system.skinnedmesh_layout().setup_layout(vao_, &vbo_);
+    }
+
+    void skinned_mesh::draw() const noexcept {
+        vao_.bind();
+        for (auto& sub : submeshes_) {
+            sub.diffuse->bind(0);
+            sub.material->bind(1);
+            sub.normal->bind(2);
+            glDrawElements(GL_TRIANGLES, sub.index_count, GL_UNSIGNED_INT,
+                reinterpret_cast<void*>(sub.offset * sizeof(unsigned int)));
+        }
+    }
+}

pool/shard006/C++/0078685_2.cc

@@ -0,0 +1,43 @@
+// 1999-05-11 bkoz
+
+// Copyright (C) 1999, 2002, 2003 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ 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 2, 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 this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 21.3.3 string capacity
+
+#include <string>
+#include <testsuite_hooks.h>
+
+// libstdc++/4548
+// http://gcc.gnu.org/ml/libstdc++/2001-11/msg00150.html
+void test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  std::string str01 = "twelve chars";
+  // str01 becomes shared
+  std::string str02 = str01;
+  str01.reserve(1);
+  VERIFY( str01.capacity() == 12 );
+}
+
+int main()
+{
+  test02();
+  return 0;
+}

pool/shard006/C++/0078686_EvaluationMetrics.cpp

@@ -0,0 +1,75 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/glue/model/EvaluationMetrics.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace Glue
+{
+namespace Model
+{
+
+EvaluationMetrics::EvaluationMetrics() : 
+    m_transformType(TransformType::NOT_SET),
+    m_transformTypeHasBeenSet(false),
+    m_findMatchesMetricsHasBeenSet(false)
+{
+}
+
+EvaluationMetrics::EvaluationMetrics(JsonView jsonValue) : 
+    m_transformType(TransformType::NOT_SET),
+    m_transformTypeHasBeenSet(false),
+    m_findMatchesMetricsHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+EvaluationMetrics& EvaluationMetrics::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("TransformType"))
+  {
+    m_transformType = TransformTypeMapper::GetTransformTypeForName(jsonValue.GetString("TransformType"));
+
+    m_transformTypeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("FindMatchesMetrics"))
+  {
+    m_findMatchesMetrics = jsonValue.GetObject("FindMatchesMetrics");
+
+    m_findMatchesMetricsHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue EvaluationMetrics::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_transformTypeHasBeenSet)
+  {
+   payload.WithString("TransformType", TransformTypeMapper::GetNameForTransformType(m_transformType));
+  }
+
+  if(m_findMatchesMetricsHasBeenSet)
+  {
+   payload.WithObject("FindMatchesMetrics", m_findMatchesMetrics.Jsonize());
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace Glue
+} // namespace Aws