text:
class Transaction(object):
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

    @property
    def value(self):
        return vars(self)


text:
package org.scalawiki.wlx.dto

case class Coordinate(lat: String, lon: String) {
  def toOpenStreetMap =
    s"""$lat, $lon"""
}

object Coordinate {
  def apply(latOpt:Option[String], lonOpt:Option[String]) = for (lat<-latOpt; lon <-lonOpt)
    yield new Coordinate(lat, lon)
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Xml.XPath;

using SandcastleBuilder.Utils.BuildEngine;

// All classes go in the SandcastleBuilder.Utils.PlugIn namespace
namespace SandcastleBuilder.Utils.PlugIn
{
    /// <summary>
    /// This interface defines the methods required to implement a build
    /// process plug-in for the Sandcastle Help File Builder.
    /// </summary>
    /// <remarks>Derived classes must also implement the
    /// <see cref="IDisposable"/> methods.</remarks>
    public interface IPlugIn : IDisposable
    {
        #region Properties
        //=====================================================================
        // Properties

        /// <summary>
        /// This read-only property returns a friendly name for the plug-in
        /// </summary>
        string Name { get; }

        /// <summary>
        /// This read-only property returns the version of the plug-in
        /// </summary>
        Version Version { get; }

        /// <summary>
        /// This read-only property returns the copyright information for the
        /// plug-in.
        /// </summary>
        string Copyright { get; }

        /// <summary>
        /// This read-only property returns a brief description of the plug-in
        /// </summary>
        string Description { get; }

        /// <summary>
        /// This read-only property returns true if the plug-in should run in
        /// a partial build or false if it should not.
        /// </summary>
        /// <value>If this returns false, the plug-in will not be loaded when
        /// a partial build is performed.</value>
        bool RunsInPartialBuild { get; }

        /// <summary>
        /// This read-only property returns a collection of execution points
        /// that define when the plug-in should be invoked during the build
        /// process.
        /// </summary>
        ExecutionPointCollection ExecutionPoints { get; }
        #endregion

        #region Methods
        //=====================================================================
        // Methods

        /// <summary>
        /// This method is used by the Sandcastle Help File Builder to let the
        /// plug-in perform its own configuration.
        /// </summary>
        /// <param name="project">A reference to the active project</param>
        /// <param name="currentConfig">The current configuration XML fragment</param>
        /// <returns>A string containing the new configuration XML fragment</returns>
        /// <remarks>The configuration data will be stored in the help file
        /// builder project.</remarks>
        string ConfigurePlugIn(SandcastleProject project, string currentConfig);

        /// <summary>
        /// This method is used to initialize the plug-in at the start of the
        /// build process.
        /// </summary>
        /// <param name="buildProcess">A reference to the current build
        /// process.</param>
        /// <param name="configuration">The configuration data that the plug-in
        /// should use to initialize itself.</param>
        void Initialize(BuildProcess buildProcess, XPathNavigator configuration);

        /// <summary>
        /// This method is used to execute the plug-in during the build process
        /// </summary>
        /// <param name="context">The current execution context</param>
        void Execute(ExecutionContext context);
        #endregion
    }
}


text:
<?php

namespace Drupal\filter\Annotation;

use Drupal\Component\Annotation\Plugin;

/**
 * Defines an filter annotation object.
 *
 * Plugin Namespace: Plugin\Filter
 *
 * For a working example, see \Drupal\filter\Plugin\Filter\FilterHtml
 *
 * @see \Drupal\filter\FilterPluginManager
 * @see \Drupal\filter\Plugin\FilterInterface
 * @see \Drupal\filter\Plugin\FilterBase
 * @see plugin_api
 *
 * @Annotation
 */
class Filter extends Plugin {

  /**
   * The plugin ID.
   *
   * @var string
   */
  public $id;

  /**
   * The name of the provider that owns the filter.
   *
   * @var string
   */
  public $provider;

  /**
   * The human-readable name of the filter.
   *
   * This is used as an administrative summary of what the filter does.
   *
   * @ingroup plugin_translatable
   *
   * @var \Drupal\Core\Annotation\Translation
   */
  public $title;

  /**
   * Additional administrative information about the filter's behavior.
   *
   * @ingroup plugin_translatable
   *
   * @var \Drupal\Core\Annotation\Translation (optional)
   */
  public $description = '';

  /**
   * A default weight for the filter in new text formats.
   *
   * @var int (optional)
   */
  public $weight = 0;

  /**
   * Whether this filter is enabled or disabled by default.
   *
   * @var bool (optional)
   */
  public $status = FALSE;

  /**
   * The default settings for the filter.
   *
   * @var array (optional)
   */
  public $settings = [];

}


text:
namespace gl
{
const char * const g_fakepath = "C:\\fakepath";

AttributeBindings::AttributeBindings()
{
}

AttributeBindings::~AttributeBindings()
{
}

InfoLog::InfoLog() : mInfoLog(NULL)
{
}

InfoLog::~InfoLog()
{
    delete[] mInfoLog;
}

int InfoLog::getLength() const
{
    if (!mInfoLog)
    {
        return 0;
    }
    else
    {
       return strlen(mInfoLog) + 1;
    }
}

void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog)
{
    int index = 0;

    if (bufSize > 0)
    {
        if (mInfoLog)
        {
            index = std::min(bufSize - 1, (int)strlen(mInfoLog));
            memcpy(infoLog, mInfoLog, index);
        }

        infoLog[index] = '\0';
    }

    if (length)
    {
        *length = index;
    }
}

// append a santized message to the program info log.
// The D3D compiler includes a fake file path in some of the warning or error
// messages, so lets remove all occurrences of this fake file path from the log.
void InfoLog::appendSanitized(const char *message)
{
    std::string msg(message);

    size_t found;
    do
    {
        found = msg.find(g_fakepath);
        if (found != std::string::npos)
        {
            msg.erase(found, strlen(g_fakepath));
        }
    }
    while (found != std::string::npos);

    append("%s", msg.c_str());
}

void InfoLog::append(const char *format, ...)
{
    if (!format)
    {
        return;
    }

    char info[1024];

    va_list vararg;
    va_start(vararg, format);
    vsnprintf(info, sizeof(info), format, vararg);
    va_end(vararg);

    size_t infoLength = strlen(info);

    if (!mInfoLog)
    {
        mInfoLog = new char[infoLength + 2];
        strcpy(mInfoLog, info);
        strcpy(mInfoLog + infoLength, "\n");
    }
    else
    {
        size_t logLength = strlen(mInfoLog);
        char *newLog = new char[logLength + infoLength + 2];
        strcpy(newLog, mInfoLog);
        strcpy(newLog + logLength, info);
        strcpy(newLog + logLength + infoLength, "\n");

        delete[] mInfoLog;
        mInfoLog = newLog;
    }
}

void InfoLog::reset()
{
    if (mInfoLog)
    {
        delete [] mInfoLog;
        mInfoLog = NULL;
    }
}

Program::Program(rx::Renderer *renderer, ResourceManager *manager, GLuint handle) : mResourceManager(manager), mHandle(handle)
{
    mFragmentShader = NULL;
    mVertexShader = NULL;
    mProgramBinary.set(NULL);
    mDeleteStatus = false;
    mLinked = false;
    mRefCount = 0;
    mRenderer = renderer;
}

Program::~Program()
{
    unlink(true);

    if (mVertexShader != NULL)
    {
        mVertexShader->release();
    }

    if (mFragmentShader != NULL)
    {
        mFragmentShader->release();
    }
}

bool Program::attachShader(Shader *shader)
{
    if (shader->getType() == GL_VERTEX_SHADER)
    {
        if (mVertexShader)
        {
            return false;
        }

        mVertexShader = (VertexShader*)shader;
        mVertexShader->addRef();
    }
    else if (shader->getType() == GL_FRAGMENT_SHADER)
    {
        if (mFragmentShader)
        {
            return false;
        }

        mFragmentShader = (FragmentShader*)shader;
        mFragmentShader->addRef();
    }
    else UNREACHABLE();

    return true;
}

bool Program::detachShader(Shader *shader)
{
    if (shader->getType() == GL_VERTEX_SHADER)
    {
        if (mVertexShader != shader)
        {
            return false;
        }

        mVertexShader->release();
        mVertexShader = NULL;
    }
    else if (shader->getType() == GL_FRAGMENT_SHADER)
    {
        if (mFragmentShader != shader)
        {
            return false;
        }

        mFragmentShader->release();
        mFragmentShader = NULL;
    }
    else UNREACHABLE();

    return true;
}

int Program::getAttachedShadersCount() const
{
    return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);
}

void AttributeBindings::bindAttributeLocation(GLuint index, const char *name)
{
    if (index < MAX_VERTEX_ATTRIBS)
    {
        for (int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
        {
            mAttributeBinding[i].erase(name);
        }

        mAttributeBinding[index].insert(name);
    }
}

void Program::bindAttributeLocation(GLuint index, const char *name)
{
    mAttributeBindings.bindAttributeLocation(index, name);
}

// Links the HLSL code of the vertex and pixel shader by matching up their varyings,
// compiling them into binaries, determining the attribute mappings, and collecting
// a list of uniforms
bool Program::link()
{
    unlink(false);

    mInfoLog.reset();

    mProgramBinary.set(new ProgramBinary(mRenderer));
    mLinked = mProgramBinary->link(mInfoLog, mAttributeBindings, mFragmentShader, mVertexShader);

    return mLinked;
}

int AttributeBindings::getAttributeBinding(const std::string &name) const
{
    for (int location = 0; location < MAX_VERTEX_ATTRIBS; location++)
    {
        if (mAttributeBinding[location].find(name) != mAttributeBinding[location].end())
        {
            return location;
        }
    }

    return -1;
}

// Returns the program object to an unlinked state, before re-linking, or at destruction
void Program::unlink(bool destroy)
{
    if (destroy)   // Object being destructed
    {
        if (mFragmentShader)
        {
            mFragmentShader->release();
            mFragmentShader = NULL;
        }

        if (mVertexShader)
        {
            mVertexShader->release();
            mVertexShader = NULL;
        }
    }

    mProgramBinary.set(NULL);
    mLinked = false;
}

bool Program::isLinked()
{
    return mLinked;
}

ProgramBinary* Program::getProgramBinary()
{
    return mProgramBinary.get();
}

bool Program::setProgramBinary(const void *binary, GLsizei length)
{
    unlink(false);

    mInfoLog.reset();

    mProgramBinary.set(new ProgramBinary(mRenderer));
    mLinked = mProgramBinary->load(mInfoLog, binary, length);
    if (!mLinked)
    {
        mProgramBinary.set(NULL);
    }

    return mLinked;
}

void Program::release()
{
    mRefCount--;

    if (mRefCount == 0 && mDeleteStatus)
    {
        mResourceManager->deleteProgram(mHandle);
    }
}

void Program::addRef()
{
    mRefCount++;
}

unsigned int Program::getRefCount() const
{
    return mRefCount;
}

GLint Program::getProgramBinaryLength() const
{
    ProgramBinary *programBinary = mProgramBinary.get();
    if (programBinary)
    {
        return programBinary->getLength();
    }
    else
    {
        return 0;
    }
}

int Program::getInfoLogLength() const
{
    return mInfoLog.getLength();
}

void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog)
{
    return mInfoLog.getLog(bufSize, length, infoLog);
}

void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders)
{
    int total = 0;

    if (mVertexShader)
    {
        if (total < maxCount)
        {
            shaders[total] = mVertexShader->getHandle();
        }

        total++;
    }

    if (mFragmentShader)
    {
        if (total < maxCount)
        {
            shaders[total] = mFragmentShader->getHandle();
        }

        total++;
    }

    if (count)
    {
        *count = total;
    }
}

void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        programBinary->getActiveAttribute(index, bufsize, length, size, type, name);
    }
    else
    {
        if (bufsize > 0)
        {
            name[0] = '\0';
        }

        if (length)
        {
            *length = 0;
        }

        *type = GL_NONE;
        *size = 1;
    }
}

GLint Program::getActiveAttributeCount()
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        return programBinary->getActiveAttributeCount();
    }
    else
    {
        return 0;
    }
}

GLint Program::getActiveAttributeMaxLength()
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        return programBinary->getActiveAttributeMaxLength();
    }
    else
    {
        return 0;
    }
}

void Program::getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        return programBinary->getActiveUniform(index, bufsize, length, size, type, name);
    }
    else
    {
        if (bufsize > 0)
        {
            name[0] = '\0';
        }

        if (length)
        {
            *length = 0;
        }

        *size = 0;
        *type = GL_NONE;
    }
}

GLint Program::getActiveUniformCount()
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        return programBinary->getActiveUniformCount();
    }
    else
    {
        return 0;
    }
}

GLint Program::getActiveUniformMaxLength()
{
    ProgramBinary *programBinary = getProgramBinary();
    if (programBinary)
    {
        return programBinary->getActiveUniformMaxLength();
    }
    else
    {
        return 0;
    }
}

void Program::flagForDeletion()
{
    mDeleteStatus = true;
}

bool Program::isFlaggedForDeletion() const
{
    return mDeleteStatus;
}

void Program::validate()
{
    mInfoLog.reset();

    ProgramBinary *programBinary = getProgramBinary();
    if (isLinked() && programBinary)
    {
        programBinary->validate(mInfoLog);
    }
    else
    {
        mInfoLog.append("Program has not been successfully linked.");
    }
}

bool Program::isValidated() const
{
    ProgramBinary *programBinary = mProgramBinary.get();
    if (programBinary)
    {
        return programBinary->isValidated();
    }
    else
    {
        return false;
    }
}

}


text:
package dtos

import "github.com/ivanthescientist/tournament_service/validators"

type PlayerBalanceResponse struct {
	validators.ValidatedDTO
	PlayerId string `json:"playerId"`
	Balance  int64  `json:"balance"`
}


text:
package org.wrl.spring.cache;

/**
 * @author: wangrl
 * @Date: 2015-12-28 10:09
 */
public class User {
    private Long id;
    private String name;
    private String email;

    public User() {
    }

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}


text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/api/documentation.proto

package com.google.api;

/**
 *

 * A documentation rule provides information about individual API elements.
 *

 *
 * Protobuf type {@code google.api.DocumentationRule}
 */
public  final class DocumentationRule extends
    com.google.protobuf.GeneratedMessageV3 implements
    // @@protoc_insertion_point(message_implements:google.api.DocumentationRule)
    DocumentationRuleOrBuilder {
  // Use DocumentationRule.newBuilder() to construct.
  private DocumentationRule(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
    super(builder);
  }
  private DocumentationRule() {
    selector_ = "";
    description_ = "";
    deprecationDescription_ = "";
  }

  @java.lang.Override
  public final com.google.protobuf.UnknownFieldSet
  getUnknownFields() {
    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
  }
  private DocumentationRule(
      com.google.protobuf.CodedInputStream input,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    this();
    int mutable_bitField0_ = 0;
    try {
      boolean done = false;
      while (!done) {
        int tag = input.readTag();
        switch (tag) {
          case 0:
            done = true;
            break;
          default: {
            if (!input.skipField(tag)) {
              done = true;
            }
            break;
          }
          case 10: {
            java.lang.String s = input.readStringRequireUtf8();

            selector_ = s;
            break;
          }
          case 18: {
            java.lang.String s = input.readStringRequireUtf8();

            description_ = s;
            break;
          }
          case 26: {
            java.lang.String s = input.readStringRequireUtf8();

            deprecationDescription_ = s;
            break;
          }
        }
      }
    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
      throw e.setUnfinishedMessage(this);
    } catch (java.io.IOException e) {
      throw new com.google.protobuf.InvalidProtocolBufferException(
          e).setUnfinishedMessage(this);
    } finally {
      makeExtensionsImmutable();
    }
  }
  public static final com.google.protobuf.Descriptors.Descriptor
      getDescriptor() {
    return com.google.api.DocumentationProto.internal_static_google_api_DocumentationRule_descriptor;
  }

  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internalGetFieldAccessorTable() {
    return com.google.api.DocumentationProto.internal_static_google_api_DocumentationRule_fieldAccessorTable
        .ensureFieldAccessorsInitialized(
            com.google.api.DocumentationRule.class, com.google.api.DocumentationRule.Builder.class);
  }

  public static final int SELECTOR_FIELD_NUMBER = 1;
  private volatile java.lang.Object selector_;
  /**
   *

   * The selector is a comma-separated list of patterns. Each pattern is a
   * qualified name of the element which may end in "*", indicating a wildcard.
   * Wildcards are only allowed at the end and for a whole component of the
   * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
   * specify a default for all applicable elements, the whole pattern "*"
   * is used.
   *

   *
   * optional string selector = 1;
   */
  public java.lang.String getSelector() {
    java.lang.Object ref = selector_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs =
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      selector_ = s;
      return s;
    }
  }
  /**
   *

   * The selector is a comma-separated list of patterns. Each pattern is a
   * qualified name of the element which may end in "*", indicating a wildcard.
   * Wildcards are only allowed at the end and for a whole component of the
   * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
   * specify a default for all applicable elements, the whole pattern "*"
   * is used.
   *

   *
   * optional string selector = 1;
   */
  public com.google.protobuf.ByteString
      getSelectorBytes() {
    java.lang.Object ref = selector_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b =
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      selector_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }

  public static final int DESCRIPTION_FIELD_NUMBER = 2;
  private volatile java.lang.Object description_;
  /**
   *

   * Description of the selected API(s).
   *

   *
   * optional string description = 2;
   */
  public java.lang.String getDescription() {
    java.lang.Object ref = description_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs =
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      description_ = s;
      return s;
    }
  }
  /**
   *

   * Description of the selected API(s).
   *

   *
   * optional string description = 2;
   */
  public com.google.protobuf.ByteString
      getDescriptionBytes() {
    java.lang.Object ref = description_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b =
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      description_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }

  public static final int DEPRECATION_DESCRIPTION_FIELD_NUMBER = 3;
  private volatile java.lang.Object deprecationDescription_;
  /**
   *

   * Deprecation description of the selected element(s). It can be provided if an
   * element is marked as `deprecated`.
   *

   *
   * optional string deprecation_description = 3;
   */
  public java.lang.String getDeprecationDescription() {
    java.lang.Object ref = deprecationDescription_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs =
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      deprecationDescription_ = s;
      return s;
    }
  }
  /**
   *

   * Deprecation description of the selected element(s). It can be provided if an
   * element is marked as `deprecated`.
   *

   *
   * optional string deprecation_description = 3;
   */
  public com.google.protobuf.ByteString
      getDeprecationDescriptionBytes() {
    java.lang.Object ref = deprecationDescription_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b =
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      deprecationDescription_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }

  private byte memoizedIsInitialized = -1;
  public final boolean isInitialized() {
    byte isInitialized = memoizedIsInitialized;
    if (isInitialized == 1) return true;
    if (isInitialized == 0) return false;

    memoizedIsInitialized = 1;
    return true;
  }

  public void writeTo(com.google.protobuf.CodedOutputStream output)
                      throws java.io.IOException {
    if (!getSelectorBytes().isEmpty()) {
      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, selector_);
    }
    if (!getDescriptionBytes().isEmpty()) {
      com.google.protobuf.GeneratedMessageV3.writeString(output, 2, description_);
    }
    if (!getDeprecationDescriptionBytes().isEmpty()) {
      com.google.protobuf.GeneratedMessageV3.writeString(output, 3, deprecationDescription_);
    }
  }

  public int getSerializedSize() {
    int size = memoizedSize;
    if (size != -1) return size;

    size = 0;
    if (!getSelectorBytes().isEmpty()) {
      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, selector_);
    }
    if (!getDescriptionBytes().isEmpty()) {
      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, description_);
    }
    if (!getDeprecationDescriptionBytes().isEmpty()) {
      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, deprecationDescription_);
    }
    memoizedSize = size;
    return size;
  }

  private static final long serialVersionUID = 0L;
  @java.lang.Override
  public boolean equals(final java.lang.Object obj) {
    if (obj == this) {
     return true;
    }
    if (!(obj instanceof com.google.api.DocumentationRule)) {
      return super.equals(obj);
    }
    com.google.api.DocumentationRule other = (com.google.api.DocumentationRule) obj;

    boolean result = true;
    result = result && getSelector()
        .equals(other.getSelector());
    result = result && getDescription()
        .equals(other.getDescription());
    result = result && getDeprecationDescription()
        .equals(other.getDeprecationDescription());
    return result;
  }

  @java.lang.Override
  public int hashCode() {
    if (memoizedHashCode != 0) {
      return memoizedHashCode;
    }
    int hash = 41;
    hash = (19 * hash) + getDescriptorForType().hashCode();
    hash = (37 * hash) + SELECTOR_FIELD_NUMBER;
    hash = (53 * hash) + getSelector().hashCode();
    hash = (37 * hash) + DESCRIPTION_FIELD_NUMBER;
    hash = (53 * hash) + getDescription().hashCode();
    hash = (37 * hash) + DEPRECATION_DESCRIPTION_FIELD_NUMBER;
    hash = (53 * hash) + getDeprecationDescription().hashCode();
    hash = (29 * hash) + unknownFields.hashCode();
    memoizedHashCode = hash;
    return hash;
  }

  public static com.google.api.DocumentationRule parseFrom(
      com.google.protobuf.ByteString data)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data);
  }
  public static com.google.api.DocumentationRule parseFrom(
      com.google.protobuf.ByteString data,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data, extensionRegistry);
  }
  public static com.google.api.DocumentationRule parseFrom(byte[] data)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data);
  }
  public static com.google.api.DocumentationRule parseFrom(
      byte[] data,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data, extensionRegistry);
  }
  public static com.google.api.DocumentationRule parseFrom(java.io.InputStream input)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseWithIOException(PARSER, input);
  }
  public static com.google.api.DocumentationRule parseFrom(
      java.io.InputStream input,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseWithIOException(PARSER, input, extensionRegistry);
  }
  public static com.google.api.DocumentationRule parseDelimitedFrom(java.io.InputStream input)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseDelimitedWithIOException(PARSER, input);
  }
  public static com.google.api.DocumentationRule parseDelimitedFrom(
      java.io.InputStream input,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
  }
  public static com.google.api.DocumentationRule parseFrom(
      com.google.protobuf.CodedInputStream input)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseWithIOException(PARSER, input);
  }
  public static com.google.api.DocumentationRule parseFrom(
      com.google.protobuf.CodedInputStream input,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3
        .parseWithIOException(PARSER, input, extensionRegistry);
  }

  public Builder newBuilderForType() { return newBuilder(); }
  public static Builder newBuilder() {
    return DEFAULT_INSTANCE.toBuilder();
  }
  public static Builder newBuilder(com.google.api.DocumentationRule prototype) {
    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
  }
  public Builder toBuilder() {
    return this == DEFAULT_INSTANCE
        ? new Builder() : new Builder().mergeFrom(this);
  }

  @java.lang.Override
  protected Builder newBuilderForType(
      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
    Builder builder = new Builder(parent);
    return builder;
  }
  /**
   *

   * A documentation rule provides information about individual API elements.
   *

   *
   * Protobuf type {@code google.api.DocumentationRule}
   */
  public static final class Builder extends
      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
      // @@protoc_insertion_point(builder_implements:google.api.DocumentationRule)
      com.google.api.DocumentationRuleOrBuilder {
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return com.google.api.DocumentationProto.internal_static_google_api_DocumentationRule_descriptor;
    }

    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return com.google.api.DocumentationProto.internal_static_google_api_DocumentationRule_fieldAccessorTable
          .ensureFieldAccessorsInitialized(
              com.google.api.DocumentationRule.class, com.google.api.DocumentationRule.Builder.class);
    }

    // Construct using com.google.api.DocumentationRule.newBuilder()
    private Builder() {
      maybeForceBuilderInitialization();
    }

    private Builder(
        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
      super(parent);
      maybeForceBuilderInitialization();
    }
    private void maybeForceBuilderInitialization() {
      if (com.google.protobuf.GeneratedMessageV3
              .alwaysUseFieldBuilders) {
      }
    }
    public Builder clear() {
      super.clear();
      selector_ = "";

      description_ = "";

      deprecationDescription_ = "";

      return this;
    }

    public com.google.protobuf.Descriptors.Descriptor
        getDescriptorForType() {
      return com.google.api.DocumentationProto.internal_static_google_api_DocumentationRule_descriptor;
    }

    public com.google.api.DocumentationRule getDefaultInstanceForType() {
      return com.google.api.DocumentationRule.getDefaultInstance();
    }

    public com.google.api.DocumentationRule build() {
      com.google.api.DocumentationRule result = buildPartial();
      if (!result.isInitialized()) {
        throw newUninitializedMessageException(result);
      }
      return result;
    }

    public com.google.api.DocumentationRule buildPartial() {
      com.google.api.DocumentationRule result = new com.google.api.DocumentationRule(this);
      result.selector_ = selector_;
      result.description_ = description_;
      result.deprecationDescription_ = deprecationDescription_;
      onBuilt();
      return result;
    }

    public Builder clone() {
      return (Builder) super.clone();
    }
    public Builder setField(
        com.google.protobuf.Descriptors.FieldDescriptor field,
        Object value) {
      return (Builder) super.setField(field, value);
    }
    public Builder clearField(
        com.google.protobuf.Descriptors.FieldDescriptor field) {
      return (Builder) super.clearField(field);
    }
    public Builder clearOneof(
        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
      return (Builder) super.clearOneof(oneof);
    }
    public Builder setRepeatedField(
        com.google.protobuf.Descriptors.FieldDescriptor field,
        int index, Object value) {
      return (Builder) super.setRepeatedField(field, index, value);
    }
    public Builder addRepeatedField(
        com.google.protobuf.Descriptors.FieldDescriptor field,
        Object value) {
      return (Builder) super.addRepeatedField(field, value);
    }
    public Builder mergeFrom(com.google.protobuf.Message other) {
      if (other instanceof com.google.api.DocumentationRule) {
        return mergeFrom((com.google.api.DocumentationRule)other);
      } else {
        super.mergeFrom(other);
        return this;
      }
    }

    public Builder mergeFrom(com.google.api.DocumentationRule other) {
      if (other == com.google.api.DocumentationRule.getDefaultInstance()) return this;
      if (!other.getSelector().isEmpty()) {
        selector_ = other.selector_;
        onChanged();
      }
      if (!other.getDescription().isEmpty()) {
        description_ = other.description_;
        onChanged();
      }
      if (!other.getDeprecationDescription().isEmpty()) {
        deprecationDescription_ = other.deprecationDescription_;
        onChanged();
      }
      onChanged();
      return this;
    }

    public final boolean isInitialized() {
      return true;
    }

    public Builder mergeFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      com.google.api.DocumentationRule parsedMessage = null;
      try {
        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
        parsedMessage = (com.google.api.DocumentationRule) e.getUnfinishedMessage();
        throw e.unwrapIOException();
      } finally {
        if (parsedMessage != null) {
          mergeFrom(parsedMessage);
        }
      }
      return this;
    }

    private java.lang.Object selector_ = "";
    /**
     *

     * The selector is a comma-separated list of patterns. Each pattern is a
     * qualified name of the element which may end in "*", indicating a wildcard.
     * Wildcards are only allowed at the end and for a whole component of the
     * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
     * specify a default for all applicable elements, the whole pattern "*"
     * is used.
     *

     *
     * optional string selector = 1;
     */
    public java.lang.String getSelector() {
      java.lang.Object ref = selector_;
      if (!(ref instanceof java.lang.String)) {
        com.google.protobuf.ByteString bs =
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        selector_ = s;
        return s;
      } else {
        return (java.lang.String) ref;
      }
    }
    /**
     *

     * The selector is a comma-separated list of patterns. Each pattern is a
     * qualified name of the element which may end in "*", indicating a wildcard.
     * Wildcards are only allowed at the end and for a whole component of the
     * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
     * specify a default for all applicable elements, the whole pattern "*"
     * is used.
     *

     *
     * optional string selector = 1;
     */
    public com.google.protobuf.ByteString
        getSelectorBytes() {
      java.lang.Object ref = selector_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b =
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        selector_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    /**
     *

     * The selector is a comma-separated list of patterns. Each pattern is a
     * qualified name of the element which may end in "*", indicating a wildcard.
     * Wildcards are only allowed at the end and for a whole component of the
     * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
     * specify a default for all applicable elements, the whole pattern "*"
     * is used.
     *

     *
     * optional string selector = 1;
     */
    public Builder setSelector(
        java.lang.String value) {
      if (value == null) {
    throw new NullPointerException();
  }

      selector_ = value;
      onChanged();
      return this;
    }
    /**
     *

     * The selector is a comma-separated list of patterns. Each pattern is a
     * qualified name of the element which may end in "*", indicating a wildcard.
     * Wildcards are only allowed at the end and for a whole component of the
     * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
     * specify a default for all applicable elements, the whole pattern "*"
     * is used.
     *

     *
     * optional string selector = 1;
     */
    public Builder clearSelector() {

      selector_ = getDefaultInstance().getSelector();
      onChanged();
      return this;
    }
    /**
     *

     * The selector is a comma-separated list of patterns. Each pattern is a
     * qualified name of the element which may end in "*", indicating a wildcard.
     * Wildcards are only allowed at the end and for a whole component of the
     * qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". To
     * specify a default for all applicable elements, the whole pattern "*"
     * is used.
     *

     *
     * optional string selector = 1;
     */
    public Builder setSelectorBytes(
        com.google.protobuf.ByteString value) {
      if (value == null) {
    throw new NullPointerException();
  }
  checkByteStringIsUtf8(value);

      selector_ = value;
      onChanged();
      return this;
    }

    private java.lang.Object description_ = "";
    /**
     *

     * Description of the selected API(s).
     *

     *
     * optional string description = 2;
     */
    public java.lang.String getDescription() {
      java.lang.Object ref = description_;
      if (!(ref instanceof java.lang.String)) {
        com.google.protobuf.ByteString bs =
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        description_ = s;
        return s;
      } else {
        return (java.lang.String) ref;
      }
    }
    /**
     *

     * Description of the selected API(s).
     *

     *
     * optional string description = 2;
     */
    public com.google.protobuf.ByteString
        getDescriptionBytes() {
      java.lang.Object ref = description_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b =
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        description_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    /**
     *

     * Description of the selected API(s).
     *

     *
     * optional string description = 2;
     */
    public Builder setDescription(
        java.lang.String value) {
      if (value == null) {
    throw new NullPointerException();
  }

      description_ = value;
      onChanged();
      return this;
    }
    /**
     *

     * Description of the selected API(s).
     *

     *
     * optional string description = 2;
     */
    public Builder clearDescription() {

      description_ = getDefaultInstance().getDescription();
      onChanged();
      return this;
    }
    /**
     *

     * Description of the selected API(s).
     *

     *
     * optional string description = 2;
     */
    public Builder setDescriptionBytes(
        com.google.protobuf.ByteString value) {
      if (value == null) {
    throw new NullPointerException();
  }
  checkByteStringIsUtf8(value);

      description_ = value;
      onChanged();
      return this;
    }

    private java.lang.Object deprecationDescription_ = "";
    /**
     *

     * Deprecation description of the selected element(s). It can be provided if an
     * element is marked as `deprecated`.
     *

     *
     * optional string deprecation_description = 3;
     */
    public java.lang.String getDeprecationDescription() {
      java.lang.Object ref = deprecationDescription_;
      if (!(ref instanceof java.lang.String)) {
        com.google.protobuf.ByteString bs =
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        deprecationDescription_ = s;
        return s;
      } else {
        return (java.lang.String) ref;
      }
    }
    /**
     *

     * Deprecation description of the selected element(s). It can be provided if an
     * element is marked as `deprecated`.
     *

     *
     * optional string deprecation_description = 3;
     */
    public com.google.protobuf.ByteString
        getDeprecationDescriptionBytes() {
      java.lang.Object ref = deprecationDescription_;
      if (ref instanceof String) {
        com.google.protobuf.ByteString b =
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        deprecationDescription_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }
    /**
     *

     * Deprecation description of the selected element(s). It can be provided if an
     * element is marked as `deprecated`.
     *

     *
     * optional string deprecation_description = 3;
     */
    public Builder setDeprecationDescription(
        java.lang.String value) {
      if (value == null) {
    throw new NullPointerException();
  }

      deprecationDescription_ = value;
      onChanged();
      return this;
    }
    /**
     *

     * Deprecation description of the selected element(s). It can be provided if an
     * element is marked as `deprecated`.
     *

     *
     * optional string deprecation_description = 3;
     */
    public Builder clearDeprecationDescription() {

      deprecationDescription_ = getDefaultInstance().getDeprecationDescription();
      onChanged();
      return this;
    }
    /**
     *

     * Deprecation description of the selected element(s). It can be provided if an
     * element is marked as `deprecated`.
     *

     *
     * optional string deprecation_description = 3;
     */
    public Builder setDeprecationDescriptionBytes(
        com.google.protobuf.ByteString value) {
      if (value == null) {
    throw new NullPointerException();
  }
  checkByteStringIsUtf8(value);

      deprecationDescription_ = value;
      onChanged();
      return this;
    }
    public final Builder setUnknownFields(
        final com.google.protobuf.UnknownFieldSet unknownFields) {
      return this;
    }

    public final Builder mergeUnknownFields(
        final com.google.protobuf.UnknownFieldSet unknownFields) {
      return this;
    }

    // @@protoc_insertion_point(builder_scope:google.api.DocumentationRule)
  }

  // @@protoc_insertion_point(class_scope:google.api.DocumentationRule)
  private static final com.google.api.DocumentationRule DEFAULT_INSTANCE;
  static {
    DEFAULT_INSTANCE = new com.google.api.DocumentationRule();
  }

  public static com.google.api.DocumentationRule getDefaultInstance() {
    return DEFAULT_INSTANCE;
  }

  private static final com.google.protobuf.Parser<DocumentationRule>
      PARSER = new com.google.protobuf.AbstractParser<DocumentationRule>() {
    public DocumentationRule parsePartialFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
        return new DocumentationRule(input, extensionRegistry);
    }
  };

  public static com.google.protobuf.Parser<DocumentationRule> parser() {
    return PARSER;
  }

  @java.lang.Override
  public com.google.protobuf.Parser<DocumentationRule> getParserForType() {
    return PARSER;
  }

  public com.google.api.DocumentationRule getDefaultInstanceForType() {
    return DEFAULT_INSTANCE;
  }

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Licensed to the Austrian Association for Software Tool Integration (AASTI)
    under one or more contributor license agreements. See the NOTICE file
    distributed with this work for additional information regarding copyright
    ownership. The AASTI licenses this file to you under the Apache License,
    Version 2.0 (the "License"); you may not use this file except in compliance
    with the License. You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.openengsb.connector</groupId>
    <artifactId>openengsb-connector-parent</artifactId>
    <version>3.1.0</version>
  </parent>

  <properties>
    <bundle.symbolicName>org.openengsb.connector.memoryauditing</bundle.symbolicName>
    <bundle.namespace>org.openengsb.connector.memoryauditing</bundle.namespace>
    <openengsb.version.min>3</openengsb.version.min>
    <openengsb.version.max>4</openengsb.version.max>
  </properties>

  <groupId>org.openengsb.connector</groupId>
  <artifactId>org.openengsb.connector.memoryauditing</artifactId>
  <version>3.0.0-SNAPSHOT</version>

  <name>OpenEngSB :: Connector :: MemoryAuditing</name>

  <packaging>bundle</packaging>

  <description>Description of Connector</description>

  <url>http://www.openengsb.org</url>

  <licenses>
    <license>
      <name>Apache 2</name>
      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
      <distribution>repo</distribution>
    </license>
  </licenses>

  <scm>
    <connection>scm:git:git://github.com/openengsb/openengsb-framework.git</connection>
    <developerConnection>scm:git:git@github.com:openengsb/openengsb-framework.git</developerConnection>
    <url>http://github.com/openengsb/openengsb-framework</url>
    <tag>HEAD</tag>
  </scm>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <extensions>true</extensions>
      </plugin>
    </plugins>
 </build>

  <dependencies>
    <dependency>
      <groupId>org.openengsb.framework</groupId>
      <artifactId>org.openengsb.framework.common</artifactId>
      <version>${project.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.openengsb.framework</groupId>
      <artifactId>org.openengsb.framework.persistence</artifactId>
      <version>${project.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.openengsb.domain</groupId>
      <artifactId>org.openengsb.domain.auditing</artifactId>
      <version>${project.version}</version>
    </dependency>
  </dependencies>

  <repositories>
    <repository> <!-- OEB snapshots are deployed here -->
      <id>sonatype-snapshots</id>
      <name>Sonaype Snapsht Repository</name>
      <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
      <releases>
        <enabled>false</enabled>
      </releases>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
  </repositories>
</project>


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Beih. Sydowia 2: 119 (1961)

#### Original name
Meliola caseariae-arboreae var. guatemalensis Hansf.

### Remarks
null


text:
/**
 * Created by duo on 2016/9/1.
 */
CMD.register("device.UIInterfaceOrientationMask", function () {
    var mask = {};

    mask[mask.INTERFACE_ORIENTATION_MASK_PORTRAIT = 2] = "INTERFACE_ORIENTATION_MASK_PORTRAIT";
    mask[mask.INTERFACE_ORIENTATION_MASK_LANDSCAPE_LEFT = 16] = "INTERFACE_ORIENTATION_MASK_LANDSCAPE_LEFT";
    mask[mask.INTERFACE_ORIENTATION_MASK_LANDSCAPE_RIGHT = 8] = "INTERFACE_ORIENTATION_MASK_LANDSCAPE_RIGHT";
    mask[mask.INTERFACE_ORIENTATION_MASK_PORTRAIT_UPSIDE_DOWN = 4] = "INTERFACE_ORIENTATION_MASK_PORTRAIT_UPSIDE_DOWN";
    mask[mask.INTERFACE_ORIENTATION_MASK_LANDSCAPE = 24] = "INTERFACE_ORIENTATION_MASK_LANDSCAPE";
    mask[mask.INTERFACE_ORIENTATION_MASK_ALL = 30] = "INTERFACE_ORIENTATION_MASK_ALL";
    mask[mask.INTERFACE_ORIENTATION_MASK_ALL_BUT_UPSIDE_DOWN = 26] = "INTERFACE_ORIENTATION_MASK_ALL_BUT_UPSIDE_DOWN";

    return mask;
});


text: HackZurich 2016 project UI


text:
db_name = node['manage-mysql-db']['mysql']['db']
mysql_database db_name do
  connection(
    host: node['manage-mysql-db']['mysql']['hostname'],
    username: node['manage-mysql-db']['mysql']['user'],
    password: node['manage-mysql-db']['mysql']['password']
  )
  action :create
end


text:
namespace engine {
core::UniquePtr<IEngineContext> CreateContext(const render::SWindowDefinition& def)
{
  auto windowModule = render::CreateDefaultWindowModule();
  if (!windowModule)
    return nullptr;

  auto window = windowModule->CreateWindow(def);
  if (!window)
    return nullptr;

  auto extensionLoader = render::CreateExtensionLoader();
  if (!extensionLoader)
    return nullptr;
  if (!extensionLoader->LoadExtensions())
    return nullptr;

  auto wnd = static_cast<render::GLFWWindow*>(window.get());
  wnd->UpdateContext();

  auto debugMonitor = render::CreateRendererDebugMessageMonitor();

  auto renderer = CreateRenderer(std::move(debugMonitor));
  if (!renderer)
    return nullptr;

  if(def.DebugContext){
    renderer->GetDebugMessageMonitor()->SetDebugging(true);
  }

  renderer->WindowResized({ (uint32_t)def.Dimensions.x, (uint32_t)def.Dimensions.y });

  wnd->SetWindowResizeCallback(
      [&renderer](core::pod::Vec2<uint32_t> size) { renderer->WindowResized(size); });

  return core::MakeUnique<EngineContext>(std::move(windowModule), std::move(window),
                                         std::move(renderer));
}

EngineContext::EngineContext(std::unique_ptr<render::DefaultWindowModule>&& windowModule,
                             std::unique_ptr<render::IWindow>&& window,
                             std::unique_ptr<render::IRenderer>&& renderer)
    : m_windowModule(std::move(windowModule))
    , m_window(std::move(window))
    , m_renderer(std::move(renderer))
{
}

EngineContext::~EngineContext()
{
}

render::IWindow* EngineContext::GetWindow()
{
  return m_window.get();
}

render::IRenderer* EngineContext::GetRenderer()
{
  return m_renderer.get();
}
} // namespace engine


text:
// npm install gulp  gulp-sass gulp-autoprefixer gulp-minify-css gulp-concat gulp-newer gulp-livereload  gulp-plumber beepbeep colors --save

var postcss = require('gulp-postcss');
var gulp = require('gulp');
var uncss = require('gulp-uncss');
var autoprefixer = require('autoprefixer-core');
var mqpacker = require('css-mqpacker');
var csswring = require('csswring');

gulp.task('default', function () {
    var processors = [
        autoprefixer({browsers: ['last 1 version']}),
        mqpacker
        // csswring
    ];
    return gulp.src('./dest/*.css')
        .pipe(postcss(processors))
        .pipe(gulp.dest('./out'));
});

gulp.task('uncss', function() {
    return gulp.src('./dest/*.css')
        .pipe(uncss({
            html: ['index.html', 'posts/**/*.html', 'http://localhost:5757/']
        }))
        .pipe(gulp.dest('./out'));
});


text:
#ifndef AERON_RING_BUFFER_MANY_TO_ONE_H
#define AERON_RING_BUFFER_MANY_TO_ONE_H

#include <limits.h>
#include <functional>
#include <algorithm>
#include <util/Index.h>
#include <util/LangUtil.h>
#include <concurrent/AtomicBuffer.h>
#include <concurrent/Atomic64.h>
#include "RingBufferDescriptor.h"
#include "RecordDescriptor.h"

namespace aeron { namespace concurrent { namespace ringbuffer {

class ManyToOneRingBuffer
{
public:
    ManyToOneRingBuffer(concurrent::AtomicBuffer& buffer) :
        m_buffer(buffer)
    {
        m_capacity = buffer.capacity() - RingBufferDescriptor::TRAILER_LENGTH;

        RingBufferDescriptor::checkCapacity(m_capacity);

        m_maxMsgLength = m_capacity / 8;

        m_tailPositionIndex = m_capacity + RingBufferDescriptor::TAIL_POSITION_OFFSET;
        m_headCachePositionIndex = m_capacity + RingBufferDescriptor::HEAD_CACHE_POSITION_OFFSET;
        m_headPositionIndex = m_capacity + RingBufferDescriptor::HEAD_POSITION_OFFSET;
        m_correlationIdCounterIndex = m_capacity + RingBufferDescriptor::CORRELATION_COUNTER_OFFSET;
        m_consumerHeartbeatIndex = m_capacity + RingBufferDescriptor::CONSUMER_HEARTBEAT_OFFSET;
    }

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

    inline util::index_t capacity() const
    {
        return m_capacity;
    }

    bool write(
        std::int32_t msgTypeId, concurrent::AtomicBuffer& srcBuffer, util::index_t srcIndex, util::index_t length)
    {
        bool isSuccessful = false;

        RecordDescriptor::checkMsgTypeId(msgTypeId);
        checkMsgLength(length);

        const util::index_t recordLength = length + RecordDescriptor::HEADER_LENGTH;
        const util::index_t requiredCapacity = util::BitUtil::align(recordLength, RecordDescriptor::ALIGNMENT);
        const util::index_t recordIndex = claimCapacity(requiredCapacity);

        if (INSUFFICIENT_CAPACITY != recordIndex)
        {
            m_buffer.putInt64Ordered(recordIndex, RecordDescriptor::makeHeader(-recordLength, msgTypeId));
            m_buffer.putBytes(RecordDescriptor::encodedMsgOffset(recordIndex), srcBuffer, srcIndex, length);
            m_buffer.putInt32Ordered(RecordDescriptor::lengthOffset(recordIndex), recordLength);

            isSuccessful = true;
        }

        return isSuccessful;
    }

    int read(const handler_t& handler, int messageCountLimit)
    {
        const std::int64_t head = m_buffer.getInt64(m_headPositionIndex);
        const std::int32_t headIndex = static_cast<std::int32_t>(head & (m_capacity - 1));
        const std::int32_t contiguousBlockLength = m_capacity - headIndex;
        int messagesRead = 0;
        int bytesRead = 0;

        auto cleanup = util::InvokeOnScopeExit {
            [&]()
            {
                if (bytesRead != 0)
                {
                    m_buffer.setMemory(headIndex, bytesRead, 0);
                    m_buffer.putInt64Ordered(m_headPositionIndex, head + bytesRead);
                }
            }};

        while ((bytesRead < contiguousBlockLength) && (messagesRead < messageCountLimit))
        {
            const std::int32_t recordIndex = headIndex + bytesRead;
            const std::int64_t header = m_buffer.getInt64Volatile(recordIndex);
            const std::int32_t recordLength = RecordDescriptor::recordLength(header);

            if (recordLength <= 0)
            {
                break;
            }

            bytesRead += util::BitUtil::align(recordLength, RecordDescriptor::ALIGNMENT);

            const std::int32_t msgTypeId = RecordDescriptor::messageTypeId(header);
            if (RecordDescriptor::PADDING_MSG_TYPE_ID == msgTypeId)
            {
                continue;
            }

            ++messagesRead;
            handler(
                msgTypeId, m_buffer, RecordDescriptor::encodedMsgOffset(recordIndex),
                recordLength - RecordDescriptor::HEADER_LENGTH);
        }

        return messagesRead;
    }

    inline int read(const handler_t& handler)
    {
        return read(handler, INT_MAX);
    }

    inline util::index_t maxMsgLength() const
    {
        return m_maxMsgLength;
    }

    inline std::int64_t nextCorrelationId()
    {
        return m_buffer.getAndAddInt64(m_correlationIdCounterIndex, 1);
    }

    inline void consumerHeartbeatTime(std::int64_t time)
    {
        m_buffer.putInt64Ordered(m_consumerHeartbeatIndex, time);
    }

    inline std::int64_t consumerHeartbeatTime() const
    {
        return m_buffer.getInt64Volatile(m_consumerHeartbeatIndex);
    }

    inline std::int64_t producerPosition() const
    {
        return m_buffer.getInt64Volatile(m_tailPositionIndex);
    }

    inline std::int64_t consumerPosition() const
    {
        return m_buffer.getInt64Volatile(m_headPositionIndex);
    }

    inline std::int32_t size() const
    {
        std::int64_t headBefore;
        std::int64_t tail;
        std::int64_t headAfter = m_buffer.getInt64Volatile(m_headPositionIndex);

        do
        {
            headBefore = headAfter;
            tail = m_buffer.getInt64Volatile(m_tailPositionIndex);
            headAfter = m_buffer.getInt64Volatile(m_headPositionIndex);
        }
        while (headAfter != headBefore);

        return static_cast<std::int32_t>(tail - headAfter);
    }

    bool unblock()
    {
        const std::int64_t headPosition = m_buffer.getInt64Volatile(m_headPositionIndex);
        const std::int64_t tailPosition = m_buffer.getInt64Volatile(m_tailPositionIndex);

        if (tailPosition == headPosition)
        {
            return false;
        }

        const util::index_t mask = m_capacity - 1;
        const std::int32_t consumerIndex = static_cast<std::int32_t>(headPosition & mask);
        const std::int32_t producerIndex = static_cast<std::int32_t>(tailPosition & mask);

        bool unblocked = false;
        std::int32_t length = m_buffer.getInt32Volatile(consumerIndex);
        if (length < 0)
        {
            m_buffer.putInt64Ordered(
                consumerIndex, RecordDescriptor::makeHeader(-length, RecordDescriptor::PADDING_MSG_TYPE_ID));
            unblocked = true;
        }
        else if (0 == length)
        {
            const std::int32_t limit = producerIndex > consumerIndex ? producerIndex : m_buffer.capacity();
            std::int32_t i = consumerIndex + RecordDescriptor::ALIGNMENT;

            do
            {
                length = m_buffer.getInt32Volatile(i);
                if (0 != length)
                {
                    if (scanBackToConfirmStillZeroed(m_buffer, i, consumerIndex))
                    {
                        m_buffer.putInt64Ordered(
                            consumerIndex,
                            RecordDescriptor::makeHeader(i - consumerIndex, RecordDescriptor::PADDING_MSG_TYPE_ID));
                        unblocked = true;
                    }

                    break;
                }

                i += RecordDescriptor::ALIGNMENT;
            }
            while (i < limit);
        }

        return unblocked;
    }

private:

    static const util::index_t INSUFFICIENT_CAPACITY = -2;

    concurrent::AtomicBuffer &m_buffer;
    util::index_t m_capacity;
    util::index_t m_maxMsgLength;
    util::index_t m_headPositionIndex;
    util::index_t m_headCachePositionIndex;
    util::index_t m_tailPositionIndex;
    util::index_t m_correlationIdCounterIndex;
    util::index_t m_consumerHeartbeatIndex;

    util::index_t claimCapacity(util::index_t requiredCapacity)
    {
        const util::index_t mask = m_capacity - 1;
        std::int64_t head = m_buffer.getInt64Volatile(m_headCachePositionIndex);

        std::int64_t tail;
        util::index_t tailIndex;
        util::index_t padding;
        do
        {
            tail = m_buffer.getInt64Volatile(m_tailPositionIndex);
            const util::index_t availableCapacity = m_capacity - static_cast<util::index_t>(tail - head);

            if (requiredCapacity > availableCapacity)
            {
                head = m_buffer.getInt64Volatile(m_headPositionIndex);

                if (requiredCapacity > (m_capacity - static_cast<util::index_t>(tail - head)))
                {
                    return INSUFFICIENT_CAPACITY;
                }

                m_buffer.putInt64Ordered(m_headCachePositionIndex, head);
            }

            padding = 0;
            tailIndex = static_cast<util::index_t>(tail & mask);
            const util::index_t toBufferEndLength = m_capacity - tailIndex;

            if (requiredCapacity > toBufferEndLength)
            {
                std::int32_t headIndex = static_cast<std::int32_t>(head & mask);

                if (requiredCapacity > headIndex)
                {
                    head = m_buffer.getInt64Volatile(m_headPositionIndex);
                    headIndex = static_cast<std::int32_t>(head & mask);

                    if (requiredCapacity > headIndex)
                    {
                        return INSUFFICIENT_CAPACITY;
                    }

                    m_buffer.putInt64Ordered(m_headCachePositionIndex, head);
                }

                padding = toBufferEndLength;
            }
        }
        while (!m_buffer.compareAndSetInt64(m_tailPositionIndex, tail, tail + requiredCapacity + padding));

        if (0 != padding)
        {
            m_buffer.putInt64Ordered(
                tailIndex, RecordDescriptor::makeHeader(padding, RecordDescriptor::PADDING_MSG_TYPE_ID));
            tailIndex = 0;
        }

        return tailIndex;
    }

    inline void checkMsgLength(util::index_t length) const
    {
        if (length > m_maxMsgLength)
        {
            throw util::IllegalArgumentException(
                "encoded message exceeds maxMsgLength of " + std::to_string(m_maxMsgLength) +
                " length=" + std::to_string(length),
                SOURCEINFO);
        }
    }

    inline static bool scanBackToConfirmStillZeroed(const AtomicBuffer& buffer, std::int32_t from, std::int32_t limit)
    {
        std::int32_t i = from - RecordDescriptor::ALIGNMENT;
        bool allZeroes = true;

        while (i >= limit)
        {
            if (0 != buffer.getInt32Volatile(i))
            {
                allZeroes = false;
                break;
            }

            i -= RecordDescriptor::ALIGNMENT;
        }

        return allZeroes;
    }
};

}}}

#endif


text:
#ifndef QPID_BROKER_SECURECONNECTION_H
#define QPID_BROKER_SECURECONNECTION_H

#include "qpid/sys/ConnectionCodec.h"
#include <memory>

namespace qpid {

namespace sys {
class SecurityLayer;
}

namespace broker {

/**
 * A ConnectionCodec 'wrapper' that allows a connection to be
 * 'secured' e.g. encrypted based on settings negotiatiated at the
 * time of establishment.
 */
class SecureConnection : public qpid::sys::ConnectionCodec
{
  public:
    SecureConnection();
    size_t decode(const char* buffer, size_t size);
    size_t encode(char* buffer, size_t size);
    bool canEncode();
    void closed();
    bool isClosed() const;
    framing::ProtocolVersion getVersion() const;
    void setCodec(std::auto_ptr<ConnectionCodec>);
    void activateSecurityLayer(std::auto_ptr<qpid::sys::SecurityLayer>, bool secureImmediately=false);
  private:
    std::auto_ptr<ConnectionCodec> codec;
    std::auto_ptr<qpid::sys::SecurityLayer> securityLayer;
    bool secured;
};
}} // namespace qpid::broker

#endif  /*!QPID_BROKER_SECURECONNECTION_H*/


text:
package esendex.sdk.java.service.resource.surveys;

import esendex.sdk.java.EsendexProperties;
import esendex.sdk.java.http.HttpQuery;
import esendex.sdk.java.http.HttpRequestMethod;
import esendex.sdk.java.model.transfer.surveys.StandardReportDto;
import esendex.sdk.java.service.auth.Authenticator;
import esendex.sdk.java.service.resource.base.XmlResponderResource;

public class SurveyReportResource extends XmlResponderResource<StandardReportDto> {

    private static EsendexProperties props = EsendexProperties.instance();

    public SurveyReportResource(Authenticator auth, String id, HttpQuery query) {
        super(auth, id, query, "1.0", props.getProperty(EsendexProperties.Key.SURVEYS_DOMAIN), props.getProperty(EsendexProperties.Key.SECURE).equals("true"));
    }

    @Override
    protected String getEndpointChild() {
        return "surveys/" + getId() + "/report/standard";
    }

    @Override
    protected HttpRequestMethod getRequestMethod() {
        return HttpRequestMethod.GET;
    }
}


text: quickly add classes to google calendar


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.4"/>
<title>libnet: libnet-types.h Source File</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

libnet
    1.1

Main Page

Files

File List

Globals

include

libnet

libnet-types.h

    1

   31

   32 #ifndef __LIBNET_TYPES_H

   33 #define __LIBNET_TYPES_H

   34

   35 /* libnet should be using the standard type names, so mapping standard

   36  * to non-standard should not be necessary. */

   37

   38 #endif  /* __LIBNET_TYPES_H */

   39

   40 /* EOF */

<address class="footer">
Generated on Wed Jan 29 2014 21:58:50 for libnet by

 1.8.4
</address>


text:
Management Commands
===================

Kong ships with management commands that allows you to easily run your tests.  There are a couple of different ways to run tests, based on how you want things to work.

check_sites
-----------

**By default, this runs tests for all your sites**

This is the main command that is used to run kong tests. By default, it does nothing, but you can pass in arguments to it, to make it do what you want.

Arguments
~~~~~~~~~

-t, --test <test_slug>
""""""""""""""""""""""

Run the tests for a specific ``Test``. This might be run across multiple ``Site``s or ``Type``s, whatever the test defines.

-s, --site <site_slug>
""""""""""""""""""""""

Run all of the tests for a specific site. This will run the tests that explicitly point at the ``Site``, as well as the tests for the ``Type`` that the site is.

-T, --type <type_slug>
""""""""""""""""""""""

Run the tests for a specific ``Type``. This will run the tests for all sites for that ``Type``.


text:
project_path: /web/_project.yaml
book_path: /web/updates/_book.yaml
description: Re-order DevTools tabs which ever way suits you best and see exactly where framework events were bound.

{# wf_updated_on: 2015-10-14 #}
{# wf_published_on: 2015-10-14 #}
{# wf_tags: devtools,digest,update #}
{# wf_featured_image: /web/updates/images/2015-08-24-devtools-digest/featured.jpg #}

# DevTools Digest: Tab Reordering, Console is #2 and Framework Event Listeners {: .page-title }

{% include "web/_shared/contributors/pbakaus.html" %}

Re-order DevTools tabs which ever way suits you best; see exactly where framework events were bound and block network requests to see which third party scripts slow you down.

## Better panel navigation: console on #2, tab reordering and nifty underlines

After investigating which areas of DevTools are used the most, it became clear that the full-screen Console panel didn't deserve the last position in the main tab bar. As second-most used panel, *it's now the second tab*. This especially matters on lower resolutions when we can't show all tabs at once.

But look, we get it. The classic order is part of your muscle memory and you'll feel dizzy for a while. Or maybe, gasp, you just hate the full screen console! Fear not, we've got you covered. The tabs can now be *reordered by dragging them around*, like so:

<video src="/web/updates/images/2015-10-05/reordering_tabs.mp4" autoplay loop></video>

The changes you make to the tab bar persist, and it works with both native tabs and extension-provided tabs. And as a bonus, we've thrown in smooth, animated underlines. Because we're nice like that.

## Support for framework event listeners

Events created by JS Frameworks such as jQuery have sometimes been a pain when working with DevTools. That's because most frameworks wrap the native DOM events into their custom event API, so looking at the event listener doesn't really reveal much about what's happening:

![Framework Listeners Off](/web/updates/images/2015-10-05/listeners_off.png)

But with the new "Framework Listeners" option in the Event Listener tab, DevTools becomes aware of the framework wrapping portion and automatically resolves it. Now, events bound by frameworks look and behave exactly like their native counterparts, telling you where it was actually bound:

![Framework Listeners On](/web/updates/images/2015-10-05/listeners_on.png)

## The best of the rest

  * [Custom Object Formatters](https://docs.google.com/document/d/1FTascZXT9cxfetuPRT2eXPQKXui4nWFivUnS_335T3U/preview?usp=sharing) allow transpiled languages such as CoffeeScript [to better format their objects](https://github.com/binaryage/cljs-devtools) in the DevTools Console.
  * The Timeline has a new better looking dialog during recording that shows you status, time and buffer usage at a glance. <br>![Timeline Hint](/web/updates/images/2015-10-05/timeline_hint.png)
  * Along the same lines, the Network Panel shows a helpful hint when empty now: ![Network Hint](/web/updates/images/2015-10-05/network_hint.png)
  * You can now filter for mixed content in the Network Panel by using the filter input and set it to `mixed-content:displayed`

- - -

As always, [let us know what you think via
Twitter](https://twitter.com/intent/tweet?text=%40ChromeDevTools) or the
comments below, and submit bugs to [crbug.com/new](https://crbug.com/new).

Until next month!
Paul Bakaus & the DevTools team

{% include "comment-widget.html" %}


text:
package controller;

import com.opendesign.td.OdDbCircle;
import model.DatabaseTeigha;

import java.util.ArrayList;

/**
 * Created by youmiss on 9/1/2014.
 */
public class EquipController {
    ArrayList<OdDbCircle> TMLs;
    DatabaseTeigha db;
    String equpimentType;
    String equipment;

    public EquipController(String equipmentType, String equipment) {
        this.equpimentType = equipmentType;
        this.equipment = equipment;
        TMLs = new ArrayList<OdDbCircle>();
        db = DatabaseTeigha.getInstance(); // Save an instance for the database
        String drawing = equipment + ".dwg";
        db.loadDrawing(drawing);
        String layerName = equipmentType + "-" + equipment + "-" + "TEXT";
        db.dumpSupportedBlocks(layerName, TMLs);
    }

    public ArrayList<OdDbCircle> getTMLs() {
        return TMLs;
    }

}


text:
import React from 'react'
import { Link } from 'react-router'
import SearchResults from '../SearchResults/SearchResults';
import SavedJobsList from '../SavedJobsList/SavedJobsList';

const DashboardNoteList = ( {props} ) => {
	return (

A JOB WILL HAVE BEEN SELECTED AT THIS POINT

My Jobs

Saved Jobs component will go here after we get the savedJobs array available to this component

                    {/*<SavedJobsList jobs={this.props.jobs}/>*/}
                    {/*This needs the savedJobsArray in state to work poperly*/}

                    <Link to='/dashboard/search-jobs'>DashboardSearchJobs</Link>

Vince's CREATE A NOTE Component goes here

My Notes

Vince's LIST OF NOTES goes here

	)
}

export default DashboardNoteList