text:
import os
import re
import glob
import subprocess
from collections import OrderedDict
from collections.abc import Mapping
from typing import Iterator

# We need to define our own `Action` method to control the verbosity of output
# and whenever we need to run those commands in a subprocess on some platforms.
from SCons import Node
from SCons.Script import Action
from SCons.Script import ARGUMENTS
from SCons.Script import Glob
from SCons.Variables.BoolVariable import _text2bool
from platform_methods import run_in_subprocess

def add_source_files(self, sources, files):
    # Convert string to list of absolute paths (including expanding wildcard)
    if isinstance(files, (str, bytes)):
        # Keep SCons project-absolute path as they are (no wildcard support)
        if files.startswith("#"):
            if "*" in files:
                print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files))
                return
            files = [files]
        else:
            # Exclude .gen.cpp files from globbing, to avoid including obsolete ones.
            # They should instead be added manually.
            skip_gen_cpp = "*" in files
            dir_path = self.Dir(".").abspath
            files = sorted(glob.glob(dir_path + "/" + files))
            if skip_gen_cpp:
                files = [f for f in files if not f.endswith(".gen.cpp")]

    # Add each path as compiled Object following environment (self) configuration
    for path in files:
        obj = self.Object(path)
        if obj in sources:
            print('WARNING: Object "{}" already included in environment sources.'.format(obj))
            continue
        sources.append(obj)

def disable_warnings(self):
    # 'self' is the environment
    if self.msvc:
        # We have to remove existing warning level defines before appending /w,
        # otherwise we get: "warning D9025 : overriding '/W3' with '/w'"
        warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"]
        self.Append(CCFLAGS=["/w"])
        self.Append(CFLAGS=["/w"])
        self.Append(CXXFLAGS=["/w"])
        self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags]
        self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags]
        self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags]
    else:
        self.Append(CCFLAGS=["-w"])
        self.Append(CFLAGS=["-w"])
        self.Append(CXXFLAGS=["-w"])

def force_optimization_on_debug(self):
    # 'self' is the environment
    if self["target"] != "debug":
        return

    if self.msvc:
        self.Append(CCFLAGS=["/O2"])
    else:
        self.Append(CCFLAGS=["-O3"])

def add_module_version_string(self, s):
    self.module_version_string += "." + s

def update_version(module_version_string=""):
    build_name = "custom_build"
    if os.getenv("BUILD_NAME") != None:
        build_name = str(os.getenv("BUILD_NAME"))
        print("Using custom build name: " + build_name)

    import version

    # NOTE: It is safe to generate this file here, since this is still executed serially
    f = open("core/version_generated.gen.h", "w")
    f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
    f.write("#ifndef VERSION_GENERATED_GEN_H\n")
    f.write("#define VERSION_GENERATED_GEN_H\n")
    f.write('#define VERSION_SHORT_NAME "' + str(version.short_name) + '"\n')
    f.write('#define VERSION_NAME "' + str(version.name) + '"\n')
    f.write("#define VERSION_MAJOR " + str(version.major) + "\n")
    f.write("#define VERSION_MINOR " + str(version.minor) + "\n")
    f.write("#define VERSION_PATCH " + str(version.patch) + "\n")
    # For dev snapshots (alpha, beta, RC, etc.) we do not commit status change to Git,
    # so this define provides a way to override it without having to modify the source.
    godot_status = str(version.status)
    if os.getenv("GODOT_VERSION_STATUS") != None:
        godot_status = str(os.getenv("GODOT_VERSION_STATUS"))
        print("Using version status '{}', overriding the original '{}'.".format(godot_status, str(version.status)))
    f.write('#define VERSION_STATUS "' + godot_status + '"\n')
    f.write('#define VERSION_BUILD "' + str(build_name) + '"\n')
    f.write('#define VERSION_MODULE_CONFIG "' + str(version.module_config) + module_version_string + '"\n')
    f.write("#define VERSION_YEAR " + str(version.year) + "\n")
    f.write('#define VERSION_WEBSITE "' + str(version.website) + '"\n')
    f.write('#define VERSION_DOCS_BRANCH "' + str(version.docs) + '"\n')
    f.write('#define VERSION_DOCS_URL "https://docs.godotengine.org/en/" VERSION_DOCS_BRANCH\n')
    f.write("#endif // VERSION_GENERATED_GEN_H\n")
    f.close()

    # NOTE: It is safe to generate this file here, since this is still executed serially
    fhash = open("core/version_hash.gen.cpp", "w")
    fhash.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
    fhash.write('#include "core/version.h"\n')
    githash = ""
    gitfolder = ".git"

    if os.path.isfile(".git"):
        module_folder = open(".git", "r").readline().strip()
        if module_folder.startswith("gitdir: "):
            gitfolder = module_folder[8:]

    if os.path.isfile(os.path.join(gitfolder, "HEAD")):
        head = open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8").readline().strip()
        if head.startswith("ref: "):
            head = os.path.join(gitfolder, head[5:])
            if os.path.isfile(head):
                githash = open(head, "r").readline().strip()
        else:
            githash = head

    fhash.write('const char *const VERSION_HASH = "' + githash + '";\n')
    fhash.close()

def parse_cg_file(fname, uniforms, sizes, conditionals):

    fs = open(fname, "r")
    line = fs.readline()

    while line:

        if re.match(r"^\s*uniform", line):

            res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")
            type = res.groups(1)
            name = res.groups(2)

            uniforms.append(name)

            if type.find("texobj") != -1:
                sizes.append(1)
            else:
                t = re.match(r"float(\d)x(\d)", type)
                if t:
                    sizes.append(int(t.groups(1)) * int(t.groups(2)))
                else:
                    t = re.match(r"float(\d)", type)
                    sizes.append(int(t.groups(1)))

            if line.find("[branch]") != -1:
                conditionals.append(name)

        line = fs.readline()

    fs.close()

def get_cmdline_bool(option, default):
    """We use `ARGUMENTS.get()` to check if options were manually overridden on the command line,
    and SCons' _text2bool helper to convert them to booleans, otherwise they're handled as strings.
    """
    cmdline_val = ARGUMENTS.get(option)
    if cmdline_val is not None:
        return _text2bool(cmdline_val)
    else:
        return default

def detect_modules(search_path, recursive=False):
    """Detects and collects a list of C++ modules at specified path

    `search_path` - a directory path containing modules. The path may point to
    a single module, which may have other nested modules. A module must have
    "register_types.h", "SCsub", "config.py" files created to be detected.

    `recursive` - if `True`, then all subdirectories are searched for modules as
    specified by the `search_path`, otherwise collects all modules under the
    `search_path` directory. If the `search_path` is a module, it is collected
    in all cases.

    Returns an `OrderedDict` with module names as keys, and directory paths as
    values. If a path is relative, then it is a built-in module. If a path is
    absolute, then it is a custom module collected outside of the engine source.
    """
    modules = OrderedDict()

    def add_module(path):
        module_name = os.path.basename(path)
        module_path = path.replace("\\", "/")  # win32
        modules[module_name] = module_path

    def is_engine(path):
        # Prevent recursively detecting modules in self and other
        # Godot sources when using `custom_modules` build option.
        version_path = os.path.join(path, "version.py")
        if os.path.exists(version_path):
            with open(version_path) as f:
                if 'short_name = "godot"' in f.read():
                    return True
        return False

    def get_files(path):
        files = glob.glob(os.path.join(path, "*"))
        # Sort so that `register_module_types` does not change that often,
        # and plugins are registered in alphabetic order as well.
        files.sort()
        return files

    if not recursive:
        if is_module(search_path):
            add_module(search_path)
        for path in get_files(search_path):
            if is_engine(path):
                continue
            if is_module(path):
                add_module(path)
    else:
        to_search = [search_path]
        while to_search:
            path = to_search.pop()
            if is_module(path):
                add_module(path)
            for child in get_files(path):
                if not os.path.isdir(child):
                    continue
                if is_engine(child):
                    continue
                to_search.insert(0, child)
    return modules

def is_module(path):
    if not os.path.isdir(path):
        return False
    must_exist = ["register_types.h", "SCsub", "config.py"]
    for f in must_exist:
        if not os.path.exists(os.path.join(path, f)):
            return False
    return True

def write_disabled_classes(class_list):
    f = open("core/disabled_classes.gen.h", "w")
    f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
    f.write("#ifndef DISABLED_CLASSES_GEN_H\n")
    f.write("#define DISABLED_CLASSES_GEN_H\n\n")
    for c in class_list:
        cs = c.strip()
        if cs != "":
            f.write("#define ClassDB_Disable_" + cs + " 1\n")
    f.write("\n#endif\n")

def write_modules(modules):
    includes_cpp = ""
    preregister_cpp = ""
    register_cpp = ""
    unregister_cpp = ""

    for name, path in modules.items():
        try:
            with open(os.path.join(path, "register_types.h")):
                includes_cpp += '#include "' + path + '/register_types.h"\n'
                preregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"
                preregister_cpp += "#ifdef MODULE_" + name.upper() + "_HAS_PREREGISTER\n"
                preregister_cpp += "\tpreregister_" + name + "_types();\n"
                preregister_cpp += "#endif\n"
                preregister_cpp += "#endif\n"
                register_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"
                register_cpp += "\tregister_" + name + "_types();\n"
                register_cpp += "#endif\n"
                unregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n"
                unregister_cpp += "\tunregister_" + name + "_types();\n"
                unregister_cpp += "#endif\n"
        except OSError:
            pass

    modules_cpp = """// register_module_types.gen.cpp
/* THIS FILE IS GENERATED DO NOT EDIT */
#include "register_module_types.h"

#include "modules/modules_enabled.gen.h"

%s

void preregister_module_types() {
%s
}

void register_module_types() {
%s
}

void unregister_module_types() {
%s
}
""" % (
        includes_cpp,
        preregister_cpp,
        register_cpp,
        unregister_cpp,
    )

    # NOTE: It is safe to generate this file here, since this is still executed serially
    with open("modules/register_module_types.gen.cpp", "w") as f:
        f.write(modules_cpp)

def convert_custom_modules_path(path):
    if not path:
        return path
    path = os.path.realpath(os.path.expanduser(os.path.expandvars(path)))
    err_msg = "Build option 'custom_modules' must %s"
    if not os.path.isdir(path):
        raise ValueError(err_msg % "point to an existing directory.")
    if path == os.path.realpath("modules"):
        raise ValueError(err_msg % "be a directory other than built-in `modules` directory.")
    return path

def disable_module(self):
    self.disabled_modules.append(self.current_module)

def module_check_dependencies(self, module, dependencies, silent=False):
    """
    Checks if module dependencies are enabled for a given module,
    and prints a warning if they aren't.
    Meant to be used in module `can_build` methods.
    Returns a boolean (True if dependencies are satisfied).
    """
    missing_deps = []
    for dep in dependencies:
        opt = "module_{}_enabled".format(dep)
        if not opt in self or not self[opt]:
            missing_deps.append(dep)

    if missing_deps != []:
        if not silent:
            print(
                "Disabling '{}' module as the following dependencies are not satisfied: {}".format(
                    module, ", ".join(missing_deps)
                )
            )
        return False
    else:
        return True

def use_windows_spawn_fix(self, platform=None):

    if os.name != "nt":
        return  # not needed, only for windows

    # On Windows, due to the limited command line length, when creating a static library
    # from a very high number of objects SCons will invoke "ar" once per object file;
    # that makes object files with same names to be overwritten so the last wins and
    # the library loses symbols defined by overwritten objects.
    # By enabling quick append instead of the default mode (replacing), libraries will
    # got built correctly regardless the invocation strategy.
    # Furthermore, since SCons will rebuild the library from scratch when an object file
    # changes, no multiple versions of the same object file will be present.
    self.Replace(ARFLAGS="q")

    def mySubProcess(cmdline, env):

        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        proc = subprocess.Popen(
            cmdline,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            startupinfo=startupinfo,
            shell=False,
            env=env,
        )
        _, err = proc.communicate()
        rv = proc.wait()
        if rv:
            print("=====")
            print(err)
            print("=====")
        return rv

    def mySpawn(sh, escape, cmd, args, env):

        newargs = " ".join(args[1:])
        cmdline = cmd + " " + newargs

        rv = 0
        env = {str(key): str(value) for key, value in iter(env.items())}
        if len(cmdline) > 32000 and cmd.endswith("ar"):
            cmdline = cmd + " " + args[1] + " " + args[2] + " "
            for i in range(3, len(args)):
                rv = mySubProcess(cmdline + args[i], env)
                if rv:
                    break
        else:
            rv = mySubProcess(cmdline, env)

        return rv

    self["SPAWN"] = mySpawn

def save_active_platforms(apnames, ap):

    for x in ap:
        names = ["logo"]
        if os.path.isfile(x + "/run_icon.png"):
            names.append("run_icon")

        for name in names:
            pngf = open(x + "/" + name + ".png", "rb")
            b = pngf.read(1)
            str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n"
            str += " static const unsigned char _" + x[9:] + "_" + name + "[]={"
            while len(b) == 1:
                str += hex(ord(b))
                b = pngf.read(1)
                if len(b) == 1:
                    str += ","

            str += "};\n"

            pngf.close()

            # NOTE: It is safe to generate this file here, since this is still executed serially
            wf = x + "/" + name + ".gen.h"
            with open(wf, "w") as pngw:
                pngw.write(str)

def no_verbose(sys, env):

    colors = {}

    # Colors are disabled in non-TTY environments such as pipes. This means
    # that if output is redirected to a file, it will not contain color codes
    if sys.stdout.isatty():
        colors["blue"] = "\033[0;94m"
        colors["bold_blue"] = "\033[1;94m"
        colors["reset"] = "\033[0m"
    else:
        colors["blue"] = ""
        colors["bold_blue"] = ""
        colors["reset"] = ""

    # There is a space before "..." to ensure that source file names can be
    # Ctrl + clicked in the VS Code terminal.
    compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    java_compile_source_message = "{}Compiling {}$SOURCE{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    compile_shared_source_message = "{}Compiling shared {}$SOURCE{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    link_program_message = "{}Linking Program {}$TARGET{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    link_library_message = "{}Linking Static Library {}$TARGET{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    ranlib_library_message = "{}Ranlib Library {}$TARGET{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    link_shared_library_message = "{}Linking Shared Library {}$TARGET{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )
    java_library_message = "{}Creating Java Archive {}$TARGET{} ...{}".format(
        colors["blue"], colors["bold_blue"], colors["blue"], colors["reset"]
    )

    env.Append(CXXCOMSTR=[compile_source_message])
    env.Append(CCCOMSTR=[compile_source_message])
    env.Append(SHCCCOMSTR=[compile_shared_source_message])
    env.Append(SHCXXCOMSTR=[compile_shared_source_message])
    env.Append(ARCOMSTR=[link_library_message])
    env.Append(RANLIBCOMSTR=[ranlib_library_message])
    env.Append(SHLINKCOMSTR=[link_shared_library_message])
    env.Append(LINKCOMSTR=[link_program_message])
    env.Append(JARCOMSTR=[java_library_message])
    env.Append(JAVACCOMSTR=[java_compile_source_message])

def detect_visual_c_compiler_version(tools_env):
    # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...
    # (see the SCons documentation for more information on what it does)...
    # in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV']
    # and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect
    # the proper vc version that will be called

    # There is no flag to give to visual c compilers to set the architecture, i.e. scons bits argument (32,64,ARM etc)
    # There are many different cl.exe files that are run, and each one compiles & links to a different architecture
    # As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()
    # is to check the PATH variable and figure out which one will be called first. Code below does that and returns:
    # the following string values:

    # ""              Compiler not detected
    # "amd64"         Native 64 bit compiler
    # "amd64_x86"     64 bit Cross Compiler for 32 bit
    # "x86"           Native 32 bit compiler
    # "x86_amd64"     32 bit Cross Compiler for 64 bit

    # There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm
    # and similar architectures/compilers

    # Set chosen compiler to "not detected"
    vc_chosen_compiler_index = -1
    vc_chosen_compiler_str = ""

    # Start with Pre VS 2017 checks which uses VCINSTALLDIR:
    if "VCINSTALLDIR" in tools_env:
        # print("Checking VCINSTALLDIR")

        # find() works with -1 so big ifs below are needed... the simplest solution, in fact
        # First test if amd64 and amd64_x86 compilers are present in the path
        vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")
        if vc_amd64_compiler_detection_index > -1:
            vc_chosen_compiler_index = vc_amd64_compiler_detection_index
            vc_chosen_compiler_str = "amd64"

        vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")
        if vc_amd64_x86_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
            vc_chosen_compiler_str = "amd64_x86"

        # Now check the 32 bit compilers
        vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")
        if vc_x86_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_x86_compiler_detection_index
            vc_chosen_compiler_str = "x86"

        vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;")
        if vc_x86_amd64_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index
            vc_chosen_compiler_str = "x86_amd64"

    # and for VS 2017 and newer we check VCTOOLSINSTALLDIR:
    if "VCTOOLSINSTALLDIR" in tools_env:

        # Newer versions have a different path available
        vc_amd64_compiler_detection_index = (
            tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;")
        )
        if vc_amd64_compiler_detection_index > -1:
            vc_chosen_compiler_index = vc_amd64_compiler_detection_index
            vc_chosen_compiler_str = "amd64"

        vc_amd64_x86_compiler_detection_index = (
            tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;")
        )
        if vc_amd64_x86_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
            vc_chosen_compiler_str = "amd64_x86"

        vc_x86_compiler_detection_index = (
            tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;")
        )
        if vc_x86_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_x86_compiler_detection_index
            vc_chosen_compiler_str = "x86"

        vc_x86_amd64_compiler_detection_index = (
            tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;")
        )
        if vc_x86_amd64_compiler_detection_index > -1 and (
            vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index
        ):
            vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index
            vc_chosen_compiler_str = "x86_amd64"

    return vc_chosen_compiler_str

def find_visual_c_batch_file(env):
    from SCons.Tool.MSCommon.vc import (
        get_default_version,
        get_host_target,
        find_batch_file,
    )

    version = get_default_version(env)
    (host_platform, target_platform, _) = get_host_target(env)
    return find_batch_file(env, version, host_platform, target_platform)[0]

def generate_cpp_hint_file(filename):
    if os.path.isfile(filename):
        # Don't overwrite an existing hint file since the user may have customized it.
        pass
    else:
        try:
            with open(filename, "w") as fd:
                fd.write("#define GDCLASS(m_class, m_inherits)\n")
        except OSError:
            print("Could not write cpp.hint file.")

def glob_recursive(pattern, node="."):
    results = []
    for f in Glob(str(node) + "/*", source=True):
        if type(f) is Node.FS.Dir:
            results += glob_recursive(pattern, f)
    results += Glob(str(node) + "/" + pattern, source=True)
    return results

def add_to_vs_project(env, sources):
    for x in sources:
        if type(x) == type(""):
            fname = env.File(x).path
        else:
            fname = env.File(x)[0].path
        pieces = fname.split(".")
        if len(pieces) > 0:
            basename = pieces[0]
            basename = basename.replace("\\\\", "/")
            if os.path.isfile(basename + ".h"):
                env.vs_incs += [basename + ".h"]
            elif os.path.isfile(basename + ".hpp"):
                env.vs_incs += [basename + ".hpp"]
            if os.path.isfile(basename + ".c"):
                env.vs_srcs += [basename + ".c"]
            elif os.path.isfile(basename + ".cpp"):
                env.vs_srcs += [basename + ".cpp"]

def generate_vs_project(env, num_jobs):
    batch_file = find_visual_c_batch_file(env)
    if batch_file:

        class ModuleConfigs(Mapping):
            # This version information (Win32, x64, Debug, Release, Release_Debug seems to be
            # required for Visual Studio to understand that it needs to generate an NMAKE
            # project. Do not modify without knowing what you are doing.
            PLATFORMS = ["Win32", "x64"]
            PLATFORM_IDS = ["32", "64"]
            CONFIGURATIONS = ["debug", "release", "release_debug"]
            CONFIGURATION_IDS = ["tools", "opt", "opt.tools"]

            @staticmethod
            def for_every_variant(value):
                return [value for _ in range(len(ModuleConfigs.CONFIGURATIONS) * len(ModuleConfigs.PLATFORMS))]

            def __init__(self):

                shared_targets_array = []
                self.names = []
                self.arg_dict = {
                    "variant": [],
                    "runfile": shared_targets_array,
                    "buildtarget": shared_targets_array,
                    "cpppaths": [],
                    "cppdefines": [],
                    "cmdargs": [],
                }
                self.add_mode()  # default

            def add_mode(
                self,
                name: str = "",
                includes: str = "",
                cli_args: str = "",
                defines=None,
            ):
                if defines is None:
                    defines = []
                self.names.append(name)
                self.arg_dict["variant"] += [
                    f'{config}{f"_[{name}]" if name else ""}|{platform}'
                    for config in ModuleConfigs.CONFIGURATIONS
                    for platform in ModuleConfigs.PLATFORMS
                ]
                self.arg_dict["runfile"] += [
                    f'bin\\godot.windows.{config_id}.{plat_id}{f".{name}" if name else ""}.exe'
                    for config_id in ModuleConfigs.CONFIGURATION_IDS
                    for plat_id in ModuleConfigs.PLATFORM_IDS
                ]
                self.arg_dict["cpppaths"] += ModuleConfigs.for_every_variant(env["CPPPATH"] + [includes])
                self.arg_dict["cppdefines"] += ModuleConfigs.for_every_variant(env["CPPDEFINES"] + defines)
                self.arg_dict["cmdargs"] += ModuleConfigs.for_every_variant(cli_args)

            def build_commandline(self, commands):

                configuration_getter = (
                    "$(Configuration"
                    + "".join([f'.Replace("{name}", "")' for name in self.names[1:]])
                    + '.Replace("_[]", "")'
                    + ")"
                )

                common_build_prefix = [
                    'cmd /V /C set "plat=$(PlatformTarget)"',
                    '(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))',
                    'set "tools=%s"' % env["tools"],
                    f'(if "{configuration_getter}"=="release" (set "tools=no"))',
                    'call "' + batch_file + '" !plat!',
                ]

                # Windows allows us to have spaces in paths, so we need
                # to double quote off the directory. However, the path ends
                # in a backslash, so we need to remove this, lest it escape the
                # last double quote off, confusing MSBuild
                common_build_postfix = [
                    "--directory=\"$(ProjectDir.TrimEnd('\\'))\"",
                    "platform=windows",
                    f"target={configuration_getter}",
                    "progress=no",
                    "tools=!tools!",
                    "-j%s" % num_jobs,
                ]

                if env["tests"]:
                    common_build_postfix.append("tests=yes")

                if env["custom_modules"]:
                    common_build_postfix.append("custom_modules=%s" % env["custom_modules"])

                result = " ^& ".join(common_build_prefix + [" ".join([commands] + common_build_postfix)])
                return result

            # Mappings interface definitions

            def __iter__(self) -> Iterator[str]:
                for x in self.arg_dict:
                    yield x

            def __len__(self) -> int:
                return len(self.names)

            def __getitem__(self, k: str):
                return self.arg_dict[k]

        add_to_vs_project(env, env.core_sources)
        add_to_vs_project(env, env.drivers_sources)
        add_to_vs_project(env, env.main_sources)
        add_to_vs_project(env, env.modules_sources)
        add_to_vs_project(env, env.scene_sources)
        add_to_vs_project(env, env.servers_sources)
        if env["tests"]:
            add_to_vs_project(env, env.tests_sources)
        add_to_vs_project(env, env.editor_sources)

        for header in glob_recursive("**/*.h"):
            env.vs_incs.append(str(header))

        module_configs = ModuleConfigs()

        if env.get("module_mono_enabled"):
            import modules.mono.build_scripts.mono_reg_utils as mono_reg

            mono_root = env.get("mono_prefix") or mono_reg.find_mono_root_dir(env["bits"])
            if mono_root:
                module_configs.add_mode(
                    "mono",
                    includes=os.path.join(mono_root, "include", "mono-2.0"),
                    cli_args="module_mono_enabled=yes mono_glue=yes",
                    defines=[("MONO_GLUE_ENABLED",)],
                )
            else:
                print("Mono installation directory not found. Generated project will not have build variants for Mono.")

        env["MSVSBUILDCOM"] = module_configs.build_commandline("scons")
        env["MSVSREBUILDCOM"] = module_configs.build_commandline("scons vsproj=yes")
        env["MSVSCLEANCOM"] = module_configs.build_commandline("scons --clean")
        if not env.get("MSVS"):
            env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj"
            env["MSVS"]["SOLUTIONSUFFIX"] = ".sln"
        env.MSVSProject(
            target=["#godot" + env["MSVSPROJECTSUFFIX"]],
            incs=env.vs_incs,
            srcs=env.vs_srcs,
            auto_build_solution=1,
            **module_configs,
        )
    else:
        print("Could not locate Visual Studio batch file to set up the build environment. Not generating VS project.")

def precious_program(env, program, sources, **args):
    program = env.ProgramOriginal(program, sources, **args)
    env.Precious(program)
    return program

def add_shared_library(env, name, sources, **args):
    library = env.SharedLibrary(name, sources, **args)
    env.NoCache(library)
    return library

def add_library(env, name, sources, **args):
    library = env.Library(name, sources, **args)
    env.NoCache(library)
    return library

def add_program(env, name, sources, **args):
    program = env.Program(name, sources, **args)
    env.NoCache(program)
    return program

def CommandNoCache(env, target, sources, command, **args):
    result = env.Command(target, sources, command, **args)
    env.NoCache(result)
    return result

def Run(env, function, short_message, subprocess=True):
    output_print = short_message if not env["verbose"] else ""
    if not subprocess:
        return Action(function, output_print)
    else:
        return Action(run_in_subprocess(function), output_print)

def detect_darwin_sdk_path(platform, env):
    sdk_name = ""
    if platform == "osx":
        sdk_name = "macosx"
        var_name = "MACOS_SDK_PATH"
    elif platform == "iphone":
        sdk_name = "iphoneos"
        var_name = "IPHONESDK"
    elif platform == "iphonesimulator":
        sdk_name = "iphonesimulator"
        var_name = "IPHONESDK"
    else:
        raise Exception("Invalid platform argument passed to detect_darwin_sdk_path")

    if not env[var_name]:
        try:
            sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8")
            if sdk_path:
                env[var_name] = sdk_path
        except (subprocess.CalledProcessError, OSError):
            print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name))
            raise

def is_vanilla_clang(env):
    if not using_clang(env):
        return False
    try:
        version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")
    except (subprocess.CalledProcessError, OSError):
        print("Couldn't parse CXX environment variable to infer compiler version.")
        return False
    return not version.startswith("Apple")

def get_compiler_version(env):
    """
    Returns an array of version numbers as ints: [major, minor, patch].
    The return array should have at least two values (major, minor).
    """
    if not env.msvc:
        # Not using -dumpversion as some GCC distros only return major, and
        # Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803
        try:
            version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8")
        except (subprocess.CalledProcessError, OSError):
            print("Couldn't parse CXX environment variable to infer compiler version.")
            return None
    else:  # TODO: Implement for MSVC
        return None
    match = re.search(
        "(?:(?<=version )|(?<=\) )|(?<=^))"
        "(?P<major>\d+)"
        "(?:\.(?P<minor>\d*))?"
        "(?:\.(?P<patch>\d*))?"
        "(?:-(?P<metadata1>[0-9a-zA-Z-]*))?"
        "(?:\+(?P<metadata2>[0-9a-zA-Z-]*))?"
        "(?: (?P<date>[0-9]{8}|[0-9]{6})(?![0-9a-zA-Z]))?",
        version,
    )
    if match is not None:
        return match.groupdict()
    else:
        return None

def using_gcc(env):
    return "gcc" in os.path.basename(env["CC"])

def using_clang(env):
    return "clang" in os.path.basename(env["CC"])

def using_emcc(env):
    return "emcc" in os.path.basename(env["CC"])

def show_progress(env):
    import sys
    from SCons.Script import Progress, Command, AlwaysBuild

    screen = sys.stdout
    # Progress reporting is not available in non-TTY environments since it
    # messes with the output (for example, when writing to a file)
    show_progress = env["progress"] and sys.stdout.isatty()
    node_count = 0
    node_count_max = 0
    node_count_interval = 1
    node_count_fname = str(env.Dir("#")) + "/.scons_node_count"

    import time, math

    class cache_progress:
        # The default is 1 GB cache and 12 hours half life
        def __init__(self, path=None, limit=1073741824, half_life=43200):
            self.path = path
            self.limit = limit
            self.exponent_scale = math.log(2) / half_life
            if env["verbose"] and path != None:
                screen.write(
                    "Current cache limit is {} (used: {})\n".format(
                        self.convert_size(limit), self.convert_size(self.get_size(path))
                    )
                )
            self.delete(self.file_list())

        def __call__(self, node, *args, **kw):
            nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress
            if show_progress:
                # Print the progress percentage
                node_count += node_count_interval
                if node_count_max > 0 and node_count <= node_count_max:
                    screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max))
                    screen.flush()
                elif node_count_max > 0 and node_count > node_count_max:
                    screen.write("\r[100%] ")
                    screen.flush()
                else:
                    screen.write("\r[Initial build] ")
                    screen.flush()

        def delete(self, files):
            if len(files) == 0:
                return
            if env["verbose"]:
                # Utter something
                screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file"))
            [os.remove(f) for f in files]

        def file_list(self):
            if self.path is None:
                # Nothing to do
                return []
            # Gather a list of (filename, (size, atime)) within the
            # cache directory
            file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))]
            if file_stat == []:
                # Nothing to do
                return []
            # Weight the cache files by size (assumed to be roughly
            # proportional to the recompilation time) times an exponential
            # decay since the ctime, and return a list with the entries
            # (filename, size, weight).
            current_time = time.time()
            file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat]
            # Sort by the most recently accessed files (most sensible to keep) first
            file_stat.sort(key=lambda x: x[2])
            # Search for the first entry where the storage limit is
            # reached
            sum, mark = 0, None
            for i, x in enumerate(file_stat):
                sum += x[1]
                if sum > self.limit:
                    mark = i
                    break
            if mark is None:
                return []
            else:
                return [x[0] for x in file_stat[mark:]]

        def convert_size(self, size_bytes):
            if size_bytes == 0:
                return "0 bytes"
            size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
            i = int(math.floor(math.log(size_bytes, 1024)))
            p = math.pow(1024, i)
            s = round(size_bytes / p, 2)
            return "%s %s" % (int(s) if i == 0 else s, size_name[i])

        def get_size(self, start_path="."):
            total_size = 0
            for dirpath, dirnames, filenames in os.walk(start_path):
                for f in filenames:
                    fp = os.path.join(dirpath, f)
                    total_size += os.path.getsize(fp)
            return total_size

    def progress_finish(target, source, env):
        nonlocal node_count, progressor
        try:
            with open(node_count_fname, "w") as f:
                f.write("%d\n" % node_count)
            progressor.delete(progressor.file_list())
        except Exception:
            pass

    try:
        with open(node_count_fname) as f:
            node_count_max = int(f.readline())
    except Exception:
        pass

    cache_directory = os.environ.get("SCONS_CACHE")
    # Simple cache pruning, attached to SCons' progress callback. Trim the
    # cache directory to a size not larger than cache_limit.
    cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024
    progressor = cache_progress(cache_directory, cache_limit)
    Progress(progressor, interval=node_count_interval)

    progress_finish_command = Command("progress_finish", [], progress_finish)
    AlwaysBuild(progress_finish_command)

def dump(env):
    # Dumps latest build information for debugging purposes and external tools.
    from json import dump

    def non_serializable(obj):
        return "<<non-serializable: %s>>" % (type(obj).__qualname__)

    with open(".scons_env.json", "w") as f:
        dump(env.Dictionary(), f, indent=4, default=non_serializable)


text:
DEPRECATED
==========

Please use https://github.com/stackforge/fuel-plugin-detach-keystone

redpajama_set_name: RedPajamaGithub


text:
FactoryBot.define do
  factory :full_object_replica do
    association :object, factory: :full_object
    cell_volume
    status :healthy
  end
end


text:
package com.thinkenterprise.repository;

import com.thinkenterprise.domain.route.Route;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

public interface RouteRepository extends CrudRepository<Route, Long> {

	Iterable<Route> findByDeparture(String departure);

    @Query(value = "select r from Route r where r.departure = :departure")
    Iterable<Route> queryFindByDeparture(@Param("departure") String departure);

    @Query(value = "select r from Route r where r.destination = :destination")
    Iterable<Route> findByDestination(@Param("destination") String destination);
}


text:
smog
====

Smog is an incremental backup tool for Tahoe-LAFS. It will watch a directory for changes and upload files to your tahoe grid. When you delete a file, smog won't touch your file so that you have time to restore it. Until your leases run out, you are able to restore the file.

__NOTE__: Smog was written as a way to explore the Go language and is sure to have many bugs. Do not rely on smog to store sensative information.

Quickstart
-----------

Build smog and run `smog start`. The program will start watching the current directory for any changes. That's it! When you want smog to stop making incremental updates just run `smog stop`.

To restore a file: `smog restore <file>`

To renew leases: `smog renew`

__NOTE__: When a file is deleted, smog assumes you are no longer interested in that file. Therefore smog will not renew its leases even though it retains information on the file. Currently there is no way to renew leases on deleted files through smog, but you are able to do so through other tahoe interfaces.


text:
[![stable](http://badges.github.io/stability-badges/dist/stable.svg)](http://github.com/badges/stability-badges)

Tests whether two arrays are almost equal; that is, any numbers are within a certain epsilon.

```js
var almostEqual = require('array-almost-equal')

//defaults to float epsilon
almostEqual(['foo', 1, 1], ['foo', 1, 1 + 1e-12]) // true
almostEqual(['bar', 2], ['foo', 2]) // false

//custom epsilon
almostEqual(['foo', 1, 0.0025], ['foo', 1, 0.0026], 0.01) // true
```

## Usage

[![NPM](https://nodei.co/npm/array-almost-equal.png)](https://www.npmjs.com/package/array-almost-equal)

#### `almostEqual(a, b[, epsilon[, relativeTolerance]])`

Tests whether `a` and `b` are arrays (or typed arrays), equal length, and all elements are strictly equal *or* numbers are almost equal.

`epsilon` defaults to [FLT_EPSILON](https://github.com/mikolalysenko/almost-equal/blob/master/almost_equal.js). `relativeTolerance` defaults to `epsilon` if not specified.

## License

MIT, see [LICENSE.md](http://github.com/Jam3/array-almost-equal/blob/master/LICENSE.md) for details.


text:
import {AxisOrient, SignalRef} from 'vega';
import {isArray} from 'vega-util';
import {FacetChannel, FACET_CHANNELS} from '../../channel';
import {title as fieldDefTitle} from '../../channeldef';
import {contains, getFirstDefined} from '../../util';
import {isSignalRef} from '../../vega.schema';
import {assembleAxis} from '../axis/assemble';
import {FacetModel} from '../facet';
import {parseGuideResolve} from '../resolve';
import {getHeaderProperty} from './common';
import {HeaderChannel, HeaderComponent} from './component';

export function getHeaderType(orient: AxisOrient | SignalRef) {
  if (orient === 'top' || orient === 'left' || isSignalRef(orient)) {
    // we always use header for orient signal since we can't dynamically make header becomes footer
    return 'header';
  }
  return 'footer';
}

export function parseFacetHeaders(model: FacetModel) {
  for (const channel of FACET_CHANNELS) {
    parseFacetHeader(model, channel);
  }

  mergeChildAxis(model, 'x');
  mergeChildAxis(model, 'y');
}

function parseFacetHeader(model: FacetModel, channel: FacetChannel) {
  const {facet, config, child, component} = model;
  if (model.channelHasField(channel)) {
    const fieldDef = facet[channel];
    const titleConfig = getHeaderProperty('title', null, config, channel);
    let title = fieldDefTitle(fieldDef, config, {
      allowDisabling: true,
      includeDefault: titleConfig === undefined || !!titleConfig
    });

    if (child.component.layoutHeaders[channel].title) {
      // TODO: better handle multiline titles
      title = isArray(title) ? title.join(', ') : title;

      // merge title with child to produce "Title / Subtitle / Sub-subtitle"
      title += ` / ${child.component.layoutHeaders[channel].title}`;
      child.component.layoutHeaders[channel].title = null;
    }

    const labelOrient = getHeaderProperty('labelOrient', fieldDef.header, config, channel);

    const labels =
      fieldDef.header !== null ? getFirstDefined(fieldDef.header?.labels, config.header.labels, true) : false;
    const headerType = contains(['bottom', 'right'], labelOrient) ? 'footer' : 'header';

    component.layoutHeaders[channel] = {
      title: fieldDef.header !== null ? title : null,
      facetFieldDef: fieldDef,
      [headerType]: channel === 'facet' ? [] : [makeHeaderComponent(model, channel, labels)]
    };
  }
}

function makeHeaderComponent(model: FacetModel, channel: HeaderChannel, labels: boolean): HeaderComponent {
  const sizeType = channel === 'row' ? 'height' : 'width';

  return {
    labels,
    sizeSignal: model.child.component.layoutSize.get(sizeType) ? model.child.getSizeSignalRef(sizeType) : undefined,
    axes: []
  };
}

function mergeChildAxis(model: FacetModel, channel: 'x' | 'y') {
  const {child} = model;
  if (child.component.axes[channel]) {
    const {layoutHeaders, resolve} = model.component;
    resolve.axis[channel] = parseGuideResolve(resolve, channel);

    if (resolve.axis[channel] === 'shared') {
      // For shared axis, move the axes to facet's header or footer
      const headerChannel = channel === 'x' ? 'column' : 'row';

      const layoutHeader = layoutHeaders[headerChannel];
      for (const axisComponent of child.component.axes[channel]) {
        const headerType = getHeaderType(axisComponent.get('orient'));
        layoutHeader[headerType] ??= [makeHeaderComponent(model, headerChannel, false)];

        // FIXME: assemble shouldn't be called here, but we do it this way so we only extract the main part of the axes
        const mainAxis = assembleAxis(axisComponent, 'main', model.config, {header: true});
        if (mainAxis) {
          // LayoutHeader no longer keep track of property precedence, thus let's combine.
          layoutHeader[headerType][0].axes.push(mainAxis);
        }
        axisComponent.mainExtracted = true;
      }
    } else {
      // Otherwise do nothing for independent axes
    }
  }
}


text:
<!doctype html>

	<meta charset="utf-8">
	<title>WOW</title>
	<link rel="stylesheet" href="css/libs/animate.css">

	<link rel="stylesheet" href="http://yui.yahooapis.com/pure/0.6.0/pure-min.css">

    <link rel="stylesheet" href="http://yui.yahooapis.com/pure/0.6.0/grids-responsive-min.css">

    <link rel="stylesheet" href="css/site.css">

				MiND & FiND
				<s class="bar"></s><s class="bar"></s>

Home

Home

Sign Up

TOPLINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE

LINE


text:
<?php

namespace Sonata\AdminBundle\Templating;

/**
 * @author Timo Bakx <timobakx@gmail.com>
 */
interface TemplateRegistryInterface
{
    /**
     * @return array 'name' => 'file_path.html.twig'
     */
    public function getTemplates();

    /**
     * @param string $name
     *
     * @return string
     */
    public function getTemplate($name);
}


text:
title: A better Linux terminal with Zsh
tags: [en]
---

![Oh My Zsh](https://cloud.githubusercontent.com/assets/2618447/6316870/710289f0-ba03-11e4-9482-25742645379d.jpg)

According to the [website][oh-my-zsh],

> Oh My Zsh is a delightful, open source, community-driven framework for managing your Zsh configuration. It comes bundled with thousands of helpful functions, helpers, plugins, themes, and a few things that make you shout... ([Source][oh-my-zsh])

On the other hand, the [Z shell (Zsh)][zsh] is

>(...) a Unix shell that can be used as an interactive login shell and as a command interpreter for shell scripting. Zsh is an extended Bourne shell with a large number of improvements, including some features of Bash, ksh, and tcsh. ([Source][zsh])

I use the Linux terminal on a daily basis, and I feel that [Oh My Zsh][oh-my-zsh] gives a better and more efficient experience out of it.
Do take a look at [what it can do for you][omz-wiki].

Installing Oh My Zsh is pretty much one of the first things I do when I'm on a new machine.

## Installing

(Partially inspired by [this][oh-my-zsh-tutorial].)

For installing, since I use Ubuntu, I do first

```zsh
$ sudo apt install zsh git
```

(If you don't have both of the above installed, the line below will throw an error.)
Continue with the instructions from [here][oh-my-zsh], which is currently the following:

```zsh
$ sh -c "$(wget https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh -O -)"
```

If the line above complains about `chsh`, just try

```zsh
$ chsh -s `which zsh`
```

Everything should be working now.
You may restart your computer.

## Note

In the future, whenever you read something that assumes you're using bash, the following file changes apply:

    .bashrc       -> .zshrc
    .bash_history -> .zsh_history
    .bash_logout  -> .zlogout (may not exist)

This may help in the future.

[oh-my-zsh]: https://ohmyz.sh/
[zsh]: https://en.wikipedia.org/wiki/Z_shell
[oh-my-zsh-tutorial]: https://gist.github.com/tsabat/1498393
[omz-wiki]: https://github.com/robbyrussell/oh-my-zsh/wiki


text:
typedef struct RingBuffer {
    int write;
    int read;
    int *data;
    int dataSize;
} RingBuffer;

void initRingBuffer(RingBuffer **buffer, int dataSize);
void writeBuffer(RingBuffer **buffer, int data);
int readBuffer(RingBuffer **buffer);


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Acta Bot. Cubana 15: 7 (1983)

#### Original name
Holubovaea roystoneicola Mercado, 1983

### Remarks
null


text:
import yaml
import json
import os
from kubernetes import client as k_client, config
from kubernetes.client.rest import ApiException
import time, datetime

class Reaper(object):
    def __init__(self,project=None):
        self.kube_client = None
        self.kube_v1_batch_client = None
        self.project = project or os.environ.get('OPENSHIFTMGR_PROJECT') or 'myproject'
        self.kube_v1_delete = None
        self.age = os.environ.get('AGE') or '1'
        self.age = int(self.age)

        # init the kube client
        self.init_kube_client()

    def init_kube_client(self):
        """
        Method to get a kube client connected to remote or local kube api
        """
        kubecfg_path = os.environ.get('KUBECFG_PATH')
        if kubecfg_path is None:
            config.load_kube_config()
        else:
            config.load_kube_config(config_file='/tmp/.kube/config')
        self.kube_client = k_client.CoreV1Api()
        self.kube_v1_batch_client = k_client.BatchV1Api()
        self.kube_v1_delete = k_client.V1DeleteOptions()

    def get_jobs(self, age=1):
        """
        Get all previously scheduled jobs for the namespace that are older than specified age, default is 1, for reaper to terminate
        age : <int> Time elapsed from start of job in days
        """
        jobs_for_reaper = []
        try:
            api_response = self.kube_v1_batch_client.list_namespaced_job(namespace=self.project, label_selector='job-origin=pman', include_uninitialized=True)
            for item in api_response.items:
                # Checking if job has finished running, either failed or succeeded
                if item.status.conditions and (item.status.failed or item.status.succeeded):
                    # Using start_time because failed jobs have no completion_time
                    start_time = item.status.start_time
                    current_time = datetime.datetime.now(datetime.timezone.utc)
                    diff = current_time-start_time
                    # 86400 = number of seconds in a day. "divmod" returns quotient and remainder as tuple e.g (1, 5.74943)
                    # means 1 day and 5.74943 sec have passed between current_time and start_time of the job
                    diff_in_seconds = divmod(diff.total_seconds(), 86400)
                    if diff_in_seconds[0] >= 1:
                        jobs_for_reaper.append(item.metadata.name)

        except ApiException as e:
            print("Exception when calling BatchV1Api->list_namespaced_job: %s\n" % e)
            exit(1)
        return jobs_for_reaper

    def delete_jobs(self):
        """
        Deletes jobs in the namespace older than age specified
        jobs : <List> list of jobs to be deleted
        """
        jobs = self.get_jobs(self.age)
        print('Jobs queued for delete: ', jobs)
        for job in jobs:
            try:
                body = k_client.V1DeleteOptions(propagation_policy='Background')
                self.kube_v1_batch_client.delete_namespaced_job(job, body=body, namespace=self.project)
                self.kube_client.delete_namespaced_persistent_volume_claim(job+"-storage-claim", self.project, {})
                print('Deleted job: ', job)
            except ApiException as e:
                print("Exception when calling BatchV1Api -> delete_namespaced_job: %s\n" % e)
                exit(1)

if __name__ == '__main__':
    reaper = Reaper()
    reaper.delete_jobs()
    exit(0)


text:
package com.frinder.frinder.adapters;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import com.frinder.frinder.R;
import com.frinder.frinder.model.Request;

import java.util.List;

import butterknife.BindView;
import butterknife.ButterKnife;

public class SentRequestAdapter extends RequestsAdapter {

    public SentRequestAdapter(Context context, List<Request> requests) {
        super(context, requests);
    }

    String getUserId(Request request) {
        return request.receiverId;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        Context context = parent.getContext();
        LayoutInflater inflater = LayoutInflater.from(context);

        // Inflate the custom layout
        View requestView = inflater.inflate(R.layout.item_request_sent, parent, false);

        // Return a new holder instance
        SentViewHolder viewHolder = new SentViewHolder(requestView);
        return viewHolder;
    }

    @Override
    public void onBindViewHolder(final ViewHolder holder, final int position) {
        super.onBindViewHolder(holder, position);

        final Request request = getRequest(position);
        SentViewHolder viewHolder = (SentViewHolder)holder;
        viewHolder.tvDelete.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                getRequestDas().deleteRequest(request);
                deleteItem(position);
            }
        });
    }

    @Override
    protected boolean shouldDisplayUnreadTag(Request request) {
        return false;
    }

    public class SentViewHolder extends RequestsAdapter.ViewHolder {

        @BindView(R.id.tvDelete)
        TextView tvDelete;

        public SentViewHolder(View itemView) {
            super(itemView);
            ButterKnife.bind(this, itemView);
        }
    }

}


text:
set(_DownloadProjectDir "${CMAKE_CURRENT_LIST_DIR}")

include(CMakeParseArguments)

function(download_project)

    set(options QUIET)
    set(oneValueArgs
            PROJ
            PREFIX
            DOWNLOAD_DIR
            SOURCE_DIR
            BINARY_DIR
            # Prevent the following from being passed through
            CONFIGURE_COMMAND
            BUILD_COMMAND
            INSTALL_COMMAND
            TEST_COMMAND
            )
    set(multiValueArgs "")

    cmake_parse_arguments(DL_ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    # Hide output if requested
    if (DL_ARGS_QUIET)
        set(OUTPUT_QUIET "OUTPUT_QUIET")
    else()
        unset(OUTPUT_QUIET)
        message(STATUS "Downloading/updating ${DL_ARGS_PROJ}")
    endif()

    # Set up where we will put our temporary CMakeLists.txt file and also
    # the base point below which the default source and binary dirs will be
    if (NOT DL_ARGS_PREFIX)
        set(DL_ARGS_PREFIX "${CMAKE_BINARY_DIR}")
    endif()
    if (NOT DL_ARGS_DOWNLOAD_DIR)
        set(DL_ARGS_DOWNLOAD_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-download")
    endif()

    # Ensure the caller can know where to find the source and build directories
    if (NOT DL_ARGS_SOURCE_DIR)
        set(DL_ARGS_SOURCE_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-src")
    endif()
    if (NOT DL_ARGS_BINARY_DIR)
        set(DL_ARGS_BINARY_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-build")
    endif()
    set(${DL_ARGS_PROJ}_SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" PARENT_SCOPE)
    set(${DL_ARGS_PROJ}_BINARY_DIR "${DL_ARGS_BINARY_DIR}" PARENT_SCOPE)

    # Create and build activate separate CMake project to carry out the download.
    # If we've already previously done these steps, they will not cause
    # anything to be updated, so extra rebuilds of the project won't occur.
    configure_file("${_DownloadProjectDir}/DownloadProject.CMakeLists.cmake.in"
            "${DL_ARGS_DOWNLOAD_DIR}/CMakeLists.txt")
    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
            ${OUTPUT_QUIET}
            WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
            )
    execute_process(COMMAND ${CMAKE_COMMAND} --build .
            ${OUTPUT_QUIET}
            WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
            )

endfunction()


text:
using System;
using System.Collections;
using System.IO;

using Microsoft.Extensions.Options;

using WheburfearnofeKellehere.Contracts.Services;
using WheburfearnofeKellehere.Core.Contracts.Services;
using WheburfearnofeKellehere.Models;

namespace WheburfearnofeKellehere.Services
{
    public class PersistAndRestoreService : IPersistAndRestoreService
    {
        private readonly IFileService _fileService;
        private readonly AppConfig _appConfig;
        private readonly string _localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

        public PersistAndRestoreService(IFileService fileService, IOptions<AppConfig> appConfig)
        {
            _fileService = fileService;
            _appConfig = appConfig.Value;
        }

        public void PersistData()
        {
            if (App.Current.Properties != null)
            {
                var folderPath = Path.Combine(_localAppData, _appConfig.ConfigurationsFolder);
                var fileName = _appConfig.AppPropertiesFileName;
                _fileService.Save(folderPath, fileName, App.Current.Properties);
            }
        }

        public void RestoreData()
        {
            var folderPath = Path.Combine(_localAppData, _appConfig.ConfigurationsFolder);
            var fileName = _appConfig.AppPropertiesFileName;
            var properties = _fileService.Read<IDictionary>(folderPath, fileName);
            if (properties != null)
            {
                foreach (DictionaryEntry property in properties)
                {
                    App.Current.Properties.Add(property.Key, property.Value);
                }
            }
        }
    }
}


text:
@implementation WhiteNoiseAppDelegate

@synthesize window;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
	// Insert code here to initialize your application
}

@end


text:
package com.facebook.buck.core.description.attr;

import com.facebook.buck.core.filesystems.ForwardRelPath;
import com.facebook.buck.core.model.UnflavoredBuildTarget;
import com.facebook.buck.rules.param.ParamName;
import com.facebook.buck.util.collect.TwoArraysImmutableHashMap;
import com.google.common.collect.ImmutableSet;

/**
 * While building up the target graph, we infer implicit inputs of a rule if certain fields are
 * absent (e.g. src field). Any {@link com.facebook.buck.core.description.Description} that
 * implements this interface can modify its implicit inputs by poking at the raw build rule params.
 */
public interface ImplicitInputsInferringDescription {

  ImmutableSet<ForwardRelPath> inferInputsFromAttributes(
      UnflavoredBuildTarget buildTarget, TwoArraysImmutableHashMap<ParamName, Object> attributes);
}


text:
.class Landroid/view/AccessibilityInteractionController$PrivateHandler;
.super Landroid/os/Handler;
.source "AccessibilityInteractionController.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/view/AccessibilityInteractionController;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "PrivateHandler"
.end annotation

# static fields
.field private static final MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID:I = 0x3

.field private static final MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID:I = 0x2

.field private static final MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT:I = 0x4

.field private static final MSG_FIND_FOCUS:I = 0x5

.field private static final MSG_FOCUS_SEARCH:I = 0x6

.field private static final MSG_PERFORM_ACCESSIBILITY_ACTION:I = 0x1

# instance fields
.field final synthetic this$0:Landroid/view/AccessibilityInteractionController;

# direct methods
.method public constructor <init>(Landroid/view/AccessibilityInteractionController;Landroid/os/Looper;)V
    .locals 0
    .param p1, "this$0"    # Landroid/view/AccessibilityInteractionController;
    .param p2, "looper"    # Landroid/os/Looper;

    .prologue
    .line 1161
    iput-object p1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    .line 1162
    invoke-direct {p0, p2}, Landroid/os/Handler;-><init>(Landroid/os/Looper;)V

    .line 1161
    return-void
.end method

# virtual methods
.method public getMessageName(Landroid/os/Message;)Ljava/lang/String;
    .locals 4
    .param p1, "message"    # Landroid/os/Message;

    .prologue
    .line 1167
    iget v0, p1, Landroid/os/Message;->what:I

    .line 1168
    .local v0, "type":I
    packed-switch v0, :pswitch_data_0

    .line 1182
    new-instance v1, Ljava/lang/IllegalArgumentException;

    new-instance v2, Ljava/lang/StringBuilder;

    invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V

    const-string/jumbo v3, "Unknown message type: "

    invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2, v0}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v2

    invoke-direct {v1, v2}, Ljava/lang/IllegalArgumentException;-><init>(Ljava/lang/String;)V

    throw v1

    .line 1170
    :pswitch_0
    const-string/jumbo v1, "MSG_PERFORM_ACCESSIBILITY_ACTION"

    return-object v1

    .line 1172
    :pswitch_1
    const-string/jumbo v1, "MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_ACCESSIBILITY_ID"

    return-object v1

    .line 1174
    :pswitch_2
    const-string/jumbo v1, "MSG_FIND_ACCESSIBILITY_NODE_INFOS_BY_VIEW_ID"

    return-object v1

    .line 1176
    :pswitch_3
    const-string/jumbo v1, "MSG_FIND_ACCESSIBILITY_NODE_INFO_BY_TEXT"

    return-object v1

    .line 1178
    :pswitch_4
    const-string/jumbo v1, "MSG_FIND_FOCUS"

    return-object v1

    .line 1180
    :pswitch_5
    const-string/jumbo v1, "MSG_FOCUS_SEARCH"

    return-object v1

    .line 1168
    nop

    :pswitch_data_0
    .packed-switch 0x1
        :pswitch_0
        :pswitch_1
        :pswitch_2
        :pswitch_3
        :pswitch_4
        :pswitch_5
    .end packed-switch
.end method

.method public handleMessage(Landroid/os/Message;)V
    .locals 4
    .param p1, "message"    # Landroid/os/Message;

    .prologue
    .line 1188
    iget v0, p1, Landroid/os/Message;->what:I

    .line 1189
    .local v0, "type":I
    packed-switch v0, :pswitch_data_0

    .line 1209
    new-instance v1, Ljava/lang/IllegalArgumentException;

    new-instance v2, Ljava/lang/StringBuilder;

    invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V

    const-string/jumbo v3, "Unknown message type: "

    invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2, v0}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v2

    invoke-direct {v1, v2}, Ljava/lang/IllegalArgumentException;-><init>(Ljava/lang/String;)V

    throw v1

    .line 1191
    :pswitch_0
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap1(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    .line 1187
    :goto_0
    return-void

    .line 1194
    :pswitch_1
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap6(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    goto :goto_0

    .line 1197
    :pswitch_2
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap3(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    goto :goto_0

    .line 1200
    :pswitch_3
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap2(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    goto :goto_0

    .line 1203
    :pswitch_4
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap4(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    goto :goto_0

    .line 1206
    :pswitch_5
    iget-object v1, p0, Landroid/view/AccessibilityInteractionController$PrivateHandler;->this$0:Landroid/view/AccessibilityInteractionController;

    invoke-static {v1, p1}, Landroid/view/AccessibilityInteractionController;->-wrap5(Landroid/view/AccessibilityInteractionController;Landroid/os/Message;)V

    goto :goto_0

    .line 1189
    nop

    :pswitch_data_0
    .packed-switch 0x1
        :pswitch_1
        :pswitch_0
        :pswitch_2
        :pswitch_3
        :pswitch_4
        :pswitch_5
    .end packed-switch
.end method


text:
package org.apache.camel.language.groovy;

import org.apache.camel.Exchange;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.impl.DefaultExchange;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @version
 */
public class GroovyExpressionTest extends CamelTestSupport {
    private static final Logger LOG = LoggerFactory.getLogger(GroovyTest.class);

    protected Exchange exchange;

    @Test
    public void testExpressionReturnsTheCorrectValue() throws Exception {
        assertExpression(GroovyLanguage.groovy("exchange.in.headers['foo.bar']"), exchange, "cheese");
        assertExpression(GroovyLanguage.groovy("exchange.in.headers.name"), exchange, "James");
        assertExpression(GroovyLanguage.groovy("exchange.in.headers['doesNotExist']"), exchange, null);
    }

    @Test
    public void testPredicateEvaluation() throws Exception {
        assertPredicate(GroovyLanguage.groovy("exchange.in.headers.name == 'James'"), exchange, true);
        assertPredicate(GroovyLanguage.groovy("exchange.in.headers.name == 'Hiram'"), exchange, false);

        assertPredicate(GroovyLanguage.groovy("request.headers.name == 'James'"), exchange, true);
    }

    @Test
    public void testProcessorMutatesTheExchange() throws Exception {
        GroovyLanguage.groovy("request.headers.myNewHeader = 'ABC'").evaluate(exchange);

        assertInMessageHeader(exchange, "myNewHeader", "ABC");
    }

    @Test
    public void testInvalidExpressionFailsWithMeaningfulException() throws Exception {
        try {
            GroovyLanguage.groovy("exchange.doesNotExist").evaluate(exchange);
            fail("This test case should have thrown an exception!");
        } catch (Exception e) {
            LOG.debug("Caught expected exception: " + e, e);
            String message = e.getMessage();
            assertTrue("The message should include 'doesNotExist' but was: " + message, message.contains("doesNotExist"));
        }
    }

    @Override
    @Before
    public void setUp() throws Exception {
        exchange = new DefaultExchange(new DefaultCamelContext());
        exchange.getIn().setHeader("foo.bar", "cheese");
        exchange.getIn().setHeader("name", "James");
    }
}


text:
<!-- do not remove -->

## 1.0.3

### New Features

- support unknown `total` by passing `total='noinfer'` ([#102](https://github.com/fastai/fastprogress/pull/102)), thanks to [@seeM](https://github.com/seeM)
- support PyCharm console as TTY ([#101](https://github.com/fastai/fastprogress/issues/101))

## 1.0.2

### Bugs Squashed

- Check that stdout exposes `isatty` ([#81](https://github.com/fastai/fastprogress/pull/81)), thanks to [@scw](https://github.com/scw)

## 1.0.1

### Bugs Squashed

- Move the style overrides to a separate HTML widget ([#79](https://github.com/fastai/fastprogress/pull/79)), thanks to [@jpc](https://github.com/jpc)
  - This fixes performance problems on Safari


text:
package main

import (
	"grate/backend/mobile/app"

	_ "grate/backend/mobile/bind/java"
	_ "grate/backend/mobile/example/libhello/hi/go_hi"
)

func main() {
	app.Run(app.Callbacks{})
}


text:
#include "Camera.h"

#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/constants.hpp>

Camera::Camera(Window* window) :
	window_(window)
{
	position_	= glm::vec3(0.0f, 0.0f,  10.0f)	;
	front_		= glm::vec3(0.0f, 0.0f, -1.0f )	;
	up_			= glm::vec3(0.0f, 1.0f,  0.0f )	;

	pitch_	= 0.0f;
	yaw_ = -90.f; // Initialize yaw to -90 degrees in order to position the front at (0, 0, -1)

	movement_speed_		= 40.0f;
	look_sensitivity_	= 0.05f;

	Init();
}

GLvoid Camera::Init()
{
	yoffset_ = 0.0f;
	xoffset_ = 0.0f;
	first_mouse_movement_ = GL_TRUE;

	GLint width  = (*window_).FramebufferWidth();
	GLint height = (*window_).FramebufferHeight();

	view_mat_ = glm::lookAt(position_, position_ + front_, up_);
	projection_mat_ = glm::perspective
	(
		glm::radians(70.f),					// fovy
		((GLfloat)width / (GLfloat)height), // aspect ratio
		//1.0f, 100.f						// znear, zfar
		0.5f, 1000.0f
	);

	// Joystick handling
	joystick_ = JoystickManager::Instance();
	if ((*joystick_).JoystickPresent(JoystickManager::JOYSTICK_1))
	{
		joyaxes_ = (*joystick_).GetJoystickAxes(JoystickManager::JOYSTICK_1);
		joypresent_ = GL_TRUE;
	}
	else
	{
		joypresent_ = GL_FALSE;
	}

	t_old_ = glfwGetTime();
}

Camera::~Camera()
{
}

glm::vec3 Camera::Position()
{
	return position_;
}

glm::vec3 Camera::Direction()
{
	return front_;
}

GLvoid Camera::Update()
{
	if ((*joystick_).JoystickPresent(JoystickManager::JOYSTICK_1))
	{
		joyaxes_ = (*joystick_).GetJoystickAxes(JoystickManager::JOYSTICK_1);
		joypresent_ = GL_TRUE;
	}
	else joypresent_ = GL_FALSE;

	UpdateViewMatrix();
	UpdateProjectionMatrix();
}

GLvoid Camera::UpdateShaders(const ShaderProgram& program)
{
	program.Bind();
	UpdateViewMatrixUniform(program.ViewUniformLocation());
	UpdateProjectionMatrixUniform(program.ProjectionUniformLocation());
	UpdatePositionUniform(program.ViewPositionUniformLocation());
	program.Unbind();
}

GLvoid Camera::DoMovement()
{
	UpdateTime();
	GLfloat adjusted_speed = movement_speed_ * dt_;

	if (window_->KeyPressed(GLFW_KEY_W)) { position_ += adjusted_speed * front_; }
	if (window_->KeyPressed(GLFW_KEY_S)) { position_ -= adjusted_speed * front_; }
	if (window_->KeyPressed(GLFW_KEY_A)) { position_ -= glm::normalize(glm::cross(front_, up_)) * adjusted_speed; }
	if (window_->KeyPressed(GLFW_KEY_D)) { position_ += glm::normalize(glm::cross(front_, up_)) * adjusted_speed; }

	// TODO limit the speed if you move Forward, when the Front is towards Up, and Up at the same time
	if (window_->KeyPressed(GLFW_KEY_LEFT_SHIFT	 )) { position_ += up_ * adjusted_speed; }
	if (window_->KeyPressed(GLFW_KEY_LEFT_CONTROL)) { position_ -= up_ * adjusted_speed; }

	/** Process Joystick Inputs **/
	if (joypresent_)
	{
		// Left Analogue x
		position_ += joyaxes_.at(0) * glm::normalize(glm::cross(front_, up_)) * adjusted_speed;
		// Left Analogue y
		position_ += joyaxes_.at(1) * adjusted_speed * front_;
		// Left Trigger
		position_ -= joyaxes_.at(4) * up_ * adjusted_speed;
		// Right Trigger
		position_ += joyaxes_.at(5) * up_ * adjusted_speed;
	}
}

GLvoid Camera::DoLooking()
{
	UpdateXY();
	yaw_	+= xoffset_ * look_sensitivity_;
	pitch_	+= yoffset_ * look_sensitivity_;

	if (pitch_ > 89.0f )	{ pitch_ =  89.0f; }
	if (pitch_ < -89.0f)	{ pitch_ = -89.0f; }

	front_ = glm::normalize(
		glm::vec3(
			glm::cos(glm::radians(yaw_)) * glm::cos(glm::radians(pitch_)),
			glm::sin(glm::radians(pitch_)),
			glm::sin(glm::radians(yaw_)) * glm::cos(glm::radians(pitch_))
		)
	);
}

GLvoid Camera::UpdateViewMatrix()
{
	DoMovement();
	DoLooking();
	view_mat_ = glm::lookAt(position_, position_ + front_, up_);

}

GLvoid Camera::UpdateProjectionMatrix()
{
	GLint width = (*window_).FramebufferWidth();
	GLint height = (*window_).FramebufferHeight();
	projection_mat_ = glm::perspective(
		glm::radians(59.f),
		((GLfloat)width / (GLfloat)height),
		0.5f, 10000.f
	);

	glViewport(0, 0, (*window_).FramebufferWidth(), (*window_).FramebufferHeight());
}

GLvoid Camera::UpdateViewMatrixUniform(GLuint  view_uniform_location) const
{
	glUniformMatrix4fv(view_uniform_location, 1, GL_FALSE, glm::value_ptr(view_mat_));
}

GLvoid Camera:: UpdateProjectionMatrixUniform(GLuint  projection_uniform_location) const
{
	glUniformMatrix4fv(projection_uniform_location, 1, GL_FALSE, glm::value_ptr(projection_mat_));
}

GLvoid Camera::UpdatePositionUniform(GLuint  view_position_uniform) const
{
	glUniform3f(view_position_uniform, position_.x, position_.y, position_.z);
}

GLvoid Camera::UpdateTime()
{
	GLfloat now = glfwGetTime();
	dt_ = now - t_old_;
	t_old_ = now;
}

GLvoid Camera::UpdateXY()
{
	if (first_mouse_movement_ && (*window_).MouseMoved())
	{
		(*window_).GetMousePos(&lastx_, &lasty_);
		first_mouse_movement_ = GL_FALSE;
	}
	GLfloat x, y;
	(*window_).GetMousePos(&x, &y);

	xoffset_ = x - lastx_;
	yoffset_ = lasty_ - y;

	/** Process Joystick Inputs **/
	if (joypresent_)
	{
		// Right Analogue x
		xoffset_ += joyaxes_.at(2) * 50.f;
		// Right Analogue y
		yoffset_ += joyaxes_.at(3) * 50.f;
	}

	/*std::cout << "(" << x << ", " << y << ") "
		<< " || (" << xoffset_ << ", " << yoffset_ << ")"
		<< std::endl;*/

	lastx_ = x;
	lasty_ = y;
}


text:
#include "../../Common.hpp"

char const* const Notifier::MULTITON_MSG =
"Multiton key for this Notifier not yet initialized!";

Notifier::Notifier(void)
    : INotifier()
{ }

Notifier::Notifier(Notifier const& arg)
    : INotifier()
    , _multiton_key(arg._multiton_key)
{ }

void Notifier::sendNotification(std::string const& notification_name,
                                       void const* body,
                                       std::string const& type)
{
    getFacade().sendNotification(notification_name, body, type);
}

void Notifier::initializeNotifier(std::string const& key)
{
    _multiton_key = key;
}

std::string const& Notifier::getMultitonKey(void) const
{
    return _multiton_key;
}

IFacade& Notifier::getFacade(void)
{
    if (_multiton_key == "" )
        throw std::runtime_error(MULTITON_MSG);
    return Facade::getInstance(_multiton_key);
}

Notifier& Notifier::operator=(Notifier const& arg)
{
    _multiton_key = arg._multiton_key;
    return *this;
}

Notifier::~Notifier(void)
{ }


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Server.DataConverter.Dungeons.V1
{
    public class Dungeon
    {
        private List<DungeonMap> maps;
        public string Name { get; set; }

        public List<DungeonMap> Maps
        {
            get { return maps; }
        }

        public Dungeon()
        {
            maps = new List<DungeonMap>();
            Name = "";
        }
    }
}


text:
package signed

import (
	"github.com/endophage/gotuf/data"
)

// SigningService defines the necessary functions to determine
// if a user is able to sign with a key, and to perform signing.
type SigningService interface {
	// Sign takes a slice of keyIDs and a piece of data to sign
	// and returns a slice of signatures and an error
	Sign(keyIDs []string, data []byte) ([]data.Signature, error)
}

// KeyService provides management of keys locally. It will never
// accept or provide private keys. Communication between the KeyService
// and a SigningService happen behind the Create function.
type KeyService interface {
	// Create issues a new key pair and is responsible for loading
	// the private key into the appropriate signing service.
	// The role isn't currently used for anything, but it's here to support
	// future features
	Create(role string, algorithm data.KeyAlgorithm) (*data.PublicKey, error)
}

// CryptoService defines a unified Signing and Key Service as this
// will be most useful for most applications.
type CryptoService interface {
	SigningService
	KeyService
}

// Verifier defines an interface for verfying signatures. An implementer
// of this interface should verify signatures for one and only one
// signing scheme.
type Verifier interface {
	Verify(key data.Key, sig []byte, msg []byte) error
}


text:
package com.eegeo.ui;

public interface IViewAnimator {
    void registerLayoutChangeListener();
    void setActivePos(final float y);
    void setInactivePos(final float y);
    void animateToActive(final long durationInMs);
    void animateToInactive(final long durationInMs);
    void animateToOnScreenState(final float onScreenState);
}


text:
.. :roadmap:

Roadmap
=======
These are tasks that will be implemented in the future.

Short-term
----------

* Add a test case specifically for the quickstart
* Add CSV output convenience functions

Long-term
---------

* Add support for hierarchical segmentations
* Add matplotlib visualizations for:
	* Linear segmentations
	* Hierarchical segmentations