text:
package ru.ifmo.android_2016.irc.client;

import android.graphics.Color;
import android.support.annotation.Nullable;

import com.annimon.stream.Collectors;
import com.annimon.stream.Stream;

import java.util.List;
import java.util.Map;

import ru.ifmo.android_2016.irc.utils.Log;

import static ru.ifmo.android_2016.irc.utils.FunctionUtils.doIfNotNull;

/**
 * Created by ghost on 10/29/2016.
 */

public final class TwitchMessage extends IRCMessage {
    private final static String TAG = TwitchMessage.class.getSimpleName();

    @Nullable
    private List<Badge> badges;
    @Nullable
    private Integer color;
    @Nullable
    private String displayName;
    @Nullable
    private String id;

    private boolean mod;
    private boolean subscriber;
    private boolean turbo;
    private int roomId;
    private int userId;
    private boolean r9k;
    private boolean subsOnly;
    private int slow;
    private Notice msgId;
    private int msgParamMonths;
    @Nullable
    private String systemMsg;
    @Nullable
    private String login;
    @Nullable
    private List<Emote> emotes;
    @Nullable
    private UserType userType;
    private List<Bits> bits;
    private String broadcasterLang;
    private Integer[] emoteSets;
    private Ban ban;

    TwitchMessage() {
    }

    public static TwitchMessage fromString(String rawMessage) {
        return new TwitchMessage().parse(rawMessage);
    }

    @Override
    protected TwitchMessage parse(String rawMessage) {
        super.parse(rawMessage);
        if (tags != null) {
            addToMessage(Stream.of(tags.split(";"))
                    .map(s -> s.split("="))
                    .filter(l -> l.length > 1)
                    .collect(Collectors.toMap(l -> l[0], l -> l[1])));
        }
        return this;
    }

    private void addToMessage(Map<String, String> map) {
        badges = Badge.parse(map.get("badges"));
        color = parseColor(map.get("color"), null);
        displayName = map.get("display-name");

        emotes = Emote.parse(map.get("emotes"));

        id = map.get("id");
        mod = parseBool(map.get("mod"), false);
        subscriber = parseBool(map.get("subscriber"), false);
        turbo = parseBool(map.get("turbo"), false);
        roomId = parseNumber(map.get("room-id"), -1);
        userId = parseNumber(map.get("user-id"), -1);
        userType = UserType.parse(map.get("user-type"));
        bits = Bits.parse(map.get("bits"), getTrailing());

        emoteSets = parseEmoteSets(map.get("emote-sets"));

        broadcasterLang = map.get("broadcaster-lang");
        r9k = parseBool(map.get("r9k"), false);
        subsOnly = parseBool(map.get("subs-only"), false);
        slow = parseNumber(map.get("slow"), -1);

        msgId = Notice.parse(map.get("msg-id"));
        msgParamMonths = parseNumber(map.get("msg-param-months"), -1);
        systemMsg = parseMessage(map.get("system-msg"));
        login = map.get("login");

        ban = Ban.parse(parseMessage(map.get("ban-reason")), map.get("ban-duration"));
    }

    private static Integer[] parseEmoteSets(@Nullable String emoteSets) {
        if (emoteSets == null) return null;
        try {
            return Stream.of(emoteSets.split(",")).map(Integer::parseInt).toArray(Integer[]::new);
        } catch (NumberFormatException x) {
            throw new ParserException(x);
        }
    }

    private static Integer parseColor(@Nullable String color,
                                      @Nullable Integer defaultValue) {
        if (color == null) {
            return defaultValue;
        }
        try {
            return Color.parseColor(color);
        } catch (IllegalArgumentException x) {
            throw new ParserException(x);
        }
    }

    private static int parseNumber(String number, int defaultValue) {
        if (number == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(number);
        } catch (NumberFormatException x) {
            throw new ParserException(x);
        }
    }

    private static String parseMessage(String message) {
        if (message == null) return null;
        String result = message.replaceAll("\\\\s", " ");
        Log.d(TAG, "SystemMessage/BanReason: " + result);
        return result;
    }

    private static boolean parseBool(String value, boolean defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        switch (value) {
            case "false":
            case "0":
                return false;

            case "true":
            case "1":
                return true;

            default:
                throw new ParserException("can't parse bool " + value);
        }
    }

    @Nullable
    public String getDisplayName() {
        return displayName;
    }

    public TwitchMessage setDisplayName(@Nullable String displayName) {
        this.displayName = displayName;
        return this;
    }

    @Override
    public String getNickname() {
        return getDisplayName() == null ? super.getNickname() : getDisplayName();
    }

    @Nullable
    public List<Emote> getEmotes() {
        return emotes;
    }

    @Nullable
    public Integer getColor() {
        return color;
    }

    public TwitchMessage setColor(@Nullable Integer color) {
        this.color = color;
        return this;
    }

    @Nullable
    public List<Badge> getBadges() {
        return badges;
    }

    public Ban getBan() {
        return ban;
    }

    public TwitchMessage setEmotes(@Nullable List<Emote> emotes) {
        this.emotes = emotes;
        return this;
    }

    public Integer[] getEmoteSets() {
        return emoteSets;
    }

    public int getRoomId() {
        return roomId;
    }

    @Override
    public TwitchMessage applyExtension(MessageExtension extension) {
        super.applyExtension(extension);
        doIfNotNull(extension.setBadges(this), badges -> this.badges = badges);
        doIfNotNull(extension.addBadges(this), badges -> {
            if (this.badges != null) {
                this.badges.addAll(badges);
            } else {
                this.badges = badges;
            }
        });
        doIfNotNull(extension.setEmotes(this), emotes -> this.emotes = emotes);
        doIfNotNull(extension.addEmotes(this), emotes -> {
            if (this.emotes != null) {
                this.emotes.addAll(emotes);
            } else {
                this.emotes = emotes;
            }
        });

        return this;
    }

    public List<Bits> getBits() {
        return bits;
    }

    public TwitchMessage clone() {
        return (TwitchMessage) super.clone();
    }
}


text:
int32_t main (int32_t size, char** data)
{
    // File 'program_volume1.log' --- 5
    LOG_TRACE("Test TRACE ", 1, '.');
    LOG_INFO("Test INFO ", 2, '.');
    LOG_WARNING("Test WARNING ", 3, '.');
    LOG_ERROR("est ERROR ", 4, '.');
    LOG_FATAL("Test FATAL ", 5, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(3) << std::endl;
    // File 'program_volume2.log' --- 0

    // Monitor
    LOG_TRACE("Test TRACE ", 6, '.');
    LOG_INFO("Test INFO ", 7, '.');
    LOG_WARNING("Test WARNING ", 8, '.');
    LOG_ERROR("Test ERROR ", 9, '.');
    LOG_FATAL("Test FATAL ", 10, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_2.log") << std::endl;
    // File 'program_2_volume1.log' --- 0
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;

    // Monitor
    LOG_TRACE("Test TRACE ", 11, '.');
    LOG_INFO("Test INFO ", 12, '.');
    LOG_WARNING("Test WARNING ", 13, '.');
    LOG_ERROR("Test ERROR ", 14, '.');
    LOG_FATAL("Test FATAL ", 15, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;

    // File 'program_2_volume1.log' --- 3
    LOG_TRACE("Test TRACE ", 16, '.');
    LOG_INFO("Test INFO ", 17, '.');
    LOG_WARNING("Test WARNING ", 18, '.');
    // File 'program_2_volume2.log' --- 2
    LOG_ERROR("Test ERROR ", 19, '.');
    LOG_FATAL("Test FATAL ", 20, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(4) << std::endl;

    // File 'program_2_volume2.log' --- 4
    LOG_TRACE("Test TRACE ", 21, '.');
    LOG_INFO("Test INFO ", 22, '.');
    // File 'program_2_volume3.log' --- 3
    LOG_WARNING("Test WARNING ", 23, '.');
    LOG_ERROR("Test ERROR ", 24, '.');
    LOG_FATAL("Test FATAL ", 25, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_1") << std::endl;

    // File 'program_1_volume1.log' --- 4
    LOG_TRACE("Test TRACE ", 26, '.');
    LOG_INFO("Test INFO ", 27, '.');
    LOG_WARNING("Test WARNING ", 28, '.');
    LOG_ERROR("Test ERROR ", 29, '.');
    // File 'program_1_volume2.log' --- 1
    LOG_FATAL("Test FATAL ", 30, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(7) << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_1.log") << std::endl;

    // File 'program_1_volume1.log' --- 7
    LOG_TRACE("Test TRACE ", 31, '.');
    LOG_INFO("Test INFO ", 32, '.');
    // File 'program_1_volume2.log' --- 5
    LOG_WARNING("Test WARNING ", 33, '.');
    LOG_ERROR("Test ERROR ", 34, '.');
    LOG_FATAL("Test FATAL ", 35, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;

    // Monitor
    LOG_TRACE("Test TRACE ", 36, '.');
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;
    // File 'program_1_volume2.log' --- 7
    LOG_INFO("Test INFO ", 37, '.');
    LOG_WARNING("Test WARNING ", 38, '.');
    // File 'program_1_volume3.log' --- 2
    LOG_ERROR("Test ERROR ", 39, '.');
    LOG_FATAL("Test FATAL ", 40, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(3) << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_2.log") << std::endl;

    // File 'program_2_volume4.log' --- 3
    LOG_TRACE("Test TRACE ", 41, '.');
    LOG_INFO("Test INFO ", 42, '.');
    LOG_WARNING("Test WARNING ", 43, '.');
    // File 'program_2_volume5.log' --- 2
    LOG_ERROR("Test ERROR ", 44, '.');
    LOG_FATAL("Test FATAL ", 45, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;

    // Monitor
    LOG_TRACE("Test TRACE ", 46, '.');
    LOG_INFO("Test INFO ", 47, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(5) << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_2.log") << std::endl;

    // File 'program_2_volume1.log' --- 5
    LOG_TRACE("Test TRACE ", 48, '.');
    // File 'program_2_volume3.log' --- 5
    LOG_INFO("Test INFO ", 49, '.');
    // File 'program_2_volume4.log' --- 5
    LOG_WARNING("Test WARNING ", 50, '.');
    // File 'program_2_volume5.log' --- 5
    LOG_ERROR("Test ERROR ", 51, '.');
    LOG_FATAL("Test FATAL ", 52, '.');

    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SwitchLoggingEngine() << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().SetLogFileRecordsLimit(4) << std::endl;
    std::cerr << std::boolalpha << analyzer::framework::log::Logger::Instance().ChangeLogFileName("../log/program_1.log") << std::endl;

    // File 'program_1_volume3.log' --- 4
    LOG_TRACE("Test TRACE ", 53, '.');
    // File 'program_1_volume4.log' --- 4
    LOG_INFO("Test INFO ", 54, '.');
    LOG_WARNING("Test WARNING ", 55, '.');
    LOG_ERROR("Test ERROR ", 56, '.');
    LOG_FATAL("Test FATAL ", 57, '.');
    // File 'program_1_volume5.log' --- 0

    return EXIT_SUCCESS;
}

redpajama_set_name: RedPajamaGithub


text:
ArrayPtr <PrototypeInfo> PrototypeManager::prototypeCollection;

bool PrototypeManager::addPrototypeInfo(PrototypeInfo *prototypeInfo)
{
  if (!prototypeInfo || !prototypeInfo->getMedia())
    return Logger::writeErrorLog("Cannot add NULL PrototypeInfo");

  PrototypeManager::flushUnusedPrototypes();
  prototypeCollection.append(prototypeInfo);

  return true;
}

PrototypeInfo *PrototypeManager::getPrototypeInfo(const char* prototypePath)
{
  if (!prototypePath || prototypeCollection.isEmpty())
    return 0;

  for (size_t i = 0; i < prototypeCollection.length(); i++)
    if (prototypeCollection(i)->getMediaPath() == prototypePath)
      return prototypeCollection(i);

  return 0;
}

PrototypeInfo *PrototypeManager::getPrototypeInfo(const String& prototypePath)
{
  if (!prototypePath.getLength() || prototypeCollection.isEmpty())
    return 0;

  for (size_t i = 0; i < prototypeCollection.length(); i++)
    if (prototypeCollection(i)->getMediaPath() == prototypePath)
      return prototypeCollection(i);

  return 0;
}

PrototypeInfo *PrototypeManager::getPrototypeInfo(unsigned int index)
{
  return (index >= prototypeCollection.length()) ? 0 : prototypeCollection(index);
}

void PrototypeManager::flushUnusedPrototypes()
{
  ArrayPtr <PrototypeInfo> validPrototypes;

  for (size_t i = 0; i < prototypeCollection.length(); i++)
    if (prototypeCollection(i)->getUserCount() > 0)
      validPrototypes.append(prototypeCollection(i));
    else
    {
      deleteObject(prototypeCollection(i)->getMedia());
      deleteObject(prototypeCollection(i));
    }

  prototypeCollection = validPrototypes;
}

void PrototypeManager::flushAllPrototypes()
{
  size_t i;

  flushUnusedPrototypes();

  for (i = 0; i < prototypeCollection.length(); i++)
  {
    deleteObject(prototypeCollection(i)->getMedia());
    deleteObject(prototypeCollection(i));
  }

  prototypeCollection.clear();

  if (i) Logger::writeInfoLog(String("Flushed ") + int(i) + String(" active prototypes"));
}

void PrototypeManager::printPrototypeInfo()
{
  if (prototypeCollection.isEmpty())
    cout << "This Manager contains no prototypes." << endl;
  else
  {
    cout << "Prototype list: " << endl;
    for (size_t i = 0; i < prototypeCollection.length(); i++)
      cout <<  "<users = \"" << prototypeCollection(i)->getUserCount() << "\" "
           <<  " path = \"" << prototypeCollection(i)->getMediaPath() << "\" />" << endl;
  }
}


text:
DclgStatsSelector::Engine.routes.draw do
  resources :selectors, except: [:index] do
    post :preview, on: :collection
    get :finish, on: :member
    get :download, on: :member
    put :duplicate, on: :member
    resources :fragments, except: [:show, :index] do
      get :datasets, on: :collection
    end
  end
end


text:
from django.template import Library
from django.conf import settings
from datetime import datetime

register = Library()

@register.filter
def todate(value, format):
	return datetime.strptime(value, format)


text:
/*
Microformats Test Suite - Downloaded from github repo: microformats/tests version v0.1.26
Mocha integration test from: microformats-v2/h-org/hyperlink
The test was built on Wed May 25 2016 10:23:15 GMT+0100 (BST)
*/

assert = chai.assert;

describe('h-org', function() {
   var htmlFragment = "Mozilla Foundation";
   var expected = {"items":[{"type":["h-org"],"properties":{"name":["Mozilla Foundation"],"url":["http://mozilla.org/"]}}],"rels":{},"rel-urls":{}};

   it('hyperlink', function(){
       var doc, dom, node, options, parser, found;
       dom = new DOMParser();
       doc = dom.parseFromString( htmlFragment, 'text/html' );
       options ={
       		'document': doc,
       		'node': doc,
       		'baseUrl': 'http://example.com',
       		'dateFormat': 'html5'
       };
       found = Microformats.get( options );
       assert.deepEqual(found, expected);
   });
});


text:
// This class was sourced from the Apache Harmony project
// https://svn.apache.org/repos/asf/harmony/enhanced/java/trunk/

namespace Lucene.Net.Support.IO
{

    /// <summary>
    /// HeapByteBuffer, ReadWriteHeapByteBuffer and ReadOnlyHeapByteBuffer compose
    /// the implementation of array based byte buffers.
    /// <para/>
    /// ReadOnlyHeapByteBuffer extends HeapByteBuffer with all the write methods
    /// throwing read only exception.
    /// <para/>
    /// This class is sealed final for runtime performance.
    /// </summary>
    internal sealed class ReadOnlyHeapByteBuffer : HeapByteBuffer
    {
        internal static ReadOnlyHeapByteBuffer Copy(HeapByteBuffer other, int markOfOther)
        {
            ReadOnlyHeapByteBuffer buf = new ReadOnlyHeapByteBuffer(
                    other.backingArray, other.Capacity, other.offset);
            buf.limit = other.Limit;
            buf.position = other.Position;
            buf.mark = markOfOther;
            buf.SetOrder(other.Order);
            return buf;
        }

        internal ReadOnlyHeapByteBuffer(byte[] backingArray, int capacity, int arrayOffset)
            : base(backingArray, capacity, arrayOffset)
        {
        }

        public override ByteBuffer AsReadOnlyBuffer()
        {
            return Copy(this, mark);
        }

        public override ByteBuffer Compact()
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer Duplicate()
        {
            return Copy(this, mark);
        }

        public override bool IsReadOnly
        {
            get { return true; }
        }

        protected override byte[] ProtectedArray
        {
            get { throw new ReadOnlyBufferException(); }
        }

        protected override int ProtectedArrayOffset
        {
            get { throw new ReadOnlyBufferException(); }
        }

        protected override bool ProtectedHasArray
        {
            get { return false; }
        }

        public override ByteBuffer Put(byte b)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer Put(int index, byte b)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer Put(byte[] src, int off, int len)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutDouble(double value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutDouble(int index, double value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutSingle(float value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutSingle(int index, float value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt32(int value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt32(int index, int value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt64(int index, long value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt64(long value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt16(int index, short value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer PutInt16(short value)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer Put(ByteBuffer buf)
        {
            throw new ReadOnlyBufferException();
        }

        public override ByteBuffer Slice()
        {
            ReadOnlyHeapByteBuffer slice = new ReadOnlyHeapByteBuffer(backingArray,
                    Remaining, offset + position);
            slice.order = order;
            return slice;
        }
    }
}


text:
/*globals console, crypto */
/*jslint indent:2, node:true */
var util = require('../../src/util');

/**
 * A Core provider for getting cryptographically random buffers. This
 * functionality may not exist in all unpriviledged contexts - namely at this
 * point, firefox addon workers.
 * @Class Core_crypto
 * @constructor
 * @param {module:Module} cap The module creating this provider.
 */
var Core_crypto = function(cap, dispatchEvent) {
  'use strict';
  this.dispatchEvent = dispatchEvent;
  util.handleEvents(this);
};

/**
 * Get a random buffer of some number of bytes.
 * @param {String} str The string to send.
 * @param {Function} continuation Function to call when sending is complete.
 * @method send
 */
 Core_crypto.prototype.getRandomBytes = function(number, continuation) {
   'use strict';
   var buffer = new Uint8Array(number);
   crypto.getRandomValues(buffer);
   continuation(buffer.buffer);
};

exports.provider = Core_crypto;
exports.name = "core.crypto";


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Kew Bull. 294 (1954)

#### Original name
Orbiliaster pilosus Dennis

### Remarks
null


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.7"/>
<title>SubcloneSeeker: Class List</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

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

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

SubcloneSeeker
    1.0.0

Subclone deconvolution software framework

Main Page

Related Pages

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Index

Class Hierarchy

Class Members

 All Classes Files Functions Variables Macros Pages

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12]

 ▼NSubcloneSeeker

 CArchivable	Abstract class that defines the interface to handle archiving objects into sqlite3 database

 CCNV	Copy Number Variation

 CEventCluster	A collection class that each instance groups many SomaticEvents which share the same cell frequency

 CGenomicLocation	A point on a reference genome

 CGenomicRange	A segment on a reference genome

 CLOH	Loss of Heterozygosity

 CSegmentalMutation	Abstract data structure class that represents any segmental somatic mutation

 CSNP	Single Nucleotide Polymorphism

 CSomaticEvent	Abstract data structure class that represents any type of somatic mutation

 CSubclone	The class that represents a subclone in a subclonal structure tree

 CSubcloneLoadTreeTraverser	A tree traverser that loads an entire tree structure from a database

 CSubcloneSaveTreeTraverser	A tree traverser that saves an entire tree structure from a database

 CTreeNode	Base class for any object that can seve as a tree node

 CTreeTraverseDelegate	Delegate class handling tree traversing

 ▼CCoexistanceTable

 CClusterNotFoundError

 CClusterPairAlreadyObservedError

 CCoexistanceTraverseDelegate

 CEdgePrintTraverser	A tree traverser that prints the edges in Graphviz .dot format

 CNodePrintTraverser	A tree traverser that prints the nodes in Graphviz .dot format

 CRefGenome	Encapsulates a reference genome

 CTreeMergeTraverseSecondary	Traverse the secondary tree, and try to place every node it encounters onto the primary tree, which was given as a constructor parameter

 CTreePrintTraverser	A tree traverser that prints tree in a text format

Generated on Thu Jul 3 2014 19:31:15 for SubcloneSeeker by

     1.8.7


text:
/**
 * MapStruct mappers for mapping domain objects and Data Transfer Objects.
 */
package com.github.solairerove.service.mapper;


text:
// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
// Licensed under the Apache License, Version 2.0.

using ImageMagick;
using Xunit;

namespace Magick.NET.Core.Tests
{
    public partial class EndianReaderTests
    {
        public class TheReadShortMethod : EndianReaderTests
        {
            [Fact]
            public void ShouldReturnNullWhenBufferIsNotLongEnough()
            {
                var reader = new EndianReader(new byte[1] { 0 });

                var result = reader.ReadShort();

                Assert.Null(result);
            }

            [Fact]
            public void ShouldReadShortBigEndian()
            {
                var reader = new EndianReader(new byte[2] { 178, 164 });

                var result = reader.ReadShort();

                Assert.Equal((ushort)45732, result);
            }

            [Fact]
            public void ShouldReadShortLittleEndian()
            {
                var reader = new EndianReader(new byte[2] { 164, 178 });
                reader.IsLittleEndian = true;

                var result = reader.ReadShort();

                Assert.Equal((ushort)45732, result);
            }

            [Fact]
            public void ShouldChangeTheIndex()
            {
                var reader = new EndianReader(new byte[2] { 0, 0 });

                reader.ReadShort();

                Assert.Equal(2U, reader.Index);
            }
        }
    }
}


text:
package test

import (
	"sync"
)

// badFieldsStruct verifies that refering invalid fields fails.
type badFieldsStruct struct {
	// +checklocks:mu
	x int // +checklocksfail
}

// redundantStruct verifies that redundant annotations fail.
type redundantStruct struct {
	mu sync.Mutex

	// +checklocks:mu
	// +checklocks:mu
	x int // +checklocksfail
}

// conflictsStruct verifies that conflicting annotations fail.
type conflictsStruct struct {
	// +checkatomicignore
	// +checkatomic
	x int // +checklocksfail

	// +checkatomic
	// +checkatomicignore
	y int // +checklocksfail
}


text:
@implementation UIViewController (APUtil)

- (void) setTitle: (NSString*) title
         subTitle: (NSString*) subTitle {

    UIView* titleView = [[UIView alloc]initWithFrame:CGRectMake(0, 0, 100, 33)];
    UILabel* titleLabel = [[UILabel alloc]initWithFrame:CGRectZero];
    UILabel* subTitleLabel = [[UILabel alloc]initWithFrame:CGRectZero];

//    [titleView setTranslatesAutoresizingMaskIntoConstraints:NO];
    [titleLabel setTranslatesAutoresizingMaskIntoConstraints:NO];
    [subTitleLabel setTranslatesAutoresizingMaskIntoConstraints:NO];

    titleLabel.text = title;
    titleLabel.font = [UIFont boldSystemFontOfSize:18];
    titleLabel.minimumScaleFactor = 0.8;
    titleLabel.adjustsFontSizeToFitWidth = YES;

    subTitleLabel.text = subTitle;
    subTitleLabel.font = [UIFont systemFontOfSize:14];
    subTitleLabel.textColor = [UIColor grayColor];

    titleLabel.textAlignment = NSTextAlignmentCenter;
    subTitleLabel.textAlignment = NSTextAlignmentCenter;

    [titleView addSubview:titleLabel];
    [titleView addSubview:subTitleLabel];

    NSDictionary* labelsDict = @{@"titleLabel":titleLabel,@"subtitleLabel":subTitleLabel};
    [titleView addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|[titleLabel][subtitleLabel]|" options:0 metrics:nil views:labelsDict]];

    [titleView addConstraint:[NSLayoutConstraint constraintWithItem:titleLabel attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:titleView attribute:NSLayoutAttributeCenterX multiplier:1 constant:0]];

    [titleView addConstraint:[NSLayoutConstraint constraintWithItem:subTitleLabel attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:titleView attribute:NSLayoutAttributeCenterX multiplier:1 constant:0]];

    self.navigationItem.titleView = titleView;
}

- (void) setActitityIndicatorTitle:(nullable NSString*) title {
    if (!title) {
        self.navigationItem.titleView = nil;
        return;
    }

    //Adds a custom Loading View
    UIView* titleView = [[UIView alloc]initWithFrame:CGRectZero];

    UILabel* label = [[UILabel alloc]initWithFrame:CGRectZero];
    label.text = title;
    [label sizeToFit];
    UIActivityIndicatorView* activityIndicator = [[UIActivityIndicatorView alloc]initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleGray];
    [activityIndicator startAnimating];

    activityIndicator.translatesAutoresizingMaskIntoConstraints = NO;
    label.translatesAutoresizingMaskIntoConstraints = NO;

    [titleView addSubview:label];
    [titleView addSubview:activityIndicator];

    NSDictionary* views = @{@"label":label,@"activityIndicator":activityIndicator};
    [titleView addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"|[activityIndicator]-(4)-[label]|"options:0 metrics:nil views:views]];
    [titleView addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|[label]|"options:0 metrics:nil views:views]];
    [titleView addConstraint:[NSLayoutConstraint constraintWithItem:label attribute:NSLayoutAttributeCenterY relatedBy:NSLayoutRelationEqual toItem:activityIndicator attribute:NSLayoutAttributeCenterY multiplier:1 constant:0]];

    titleView.frame = CGRectMake(0, 0, activityIndicator.frame.size.width + 4 + label.frame.size.width, label.frame.size.height);

    self.navigationItem.titleView = titleView;
}

- (void) presentViewController:(UIViewController *)viewControllerToPresent
                      animated:(BOOL)animated
     embedNavigationController: (BOOL) embedNav
                    completion:(void (^)(void))completion {

    if (embedNav) {
        UINavigationController* nav = [[UINavigationController alloc]initWithRootViewController:viewControllerToPresent];
        nav.modalPresentationStyle = UIModalPresentationFormSheet;
        [self presentViewController:nav animated:animated completion:completion];
    } else {
        [self presentViewController:viewControllerToPresent animated:animated completion:completion];
    }

}

@end


text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <title>Runners Home Page ™</title>

Hello, Stranger!

        Welcome to Runners HomeTM

        Runners Home™ is dedicated with providing you with:

the most up-to-date information on running races.

the best resources for runners.

        © Runners Home. All rights reserved.


text:
#ifndef InspectorProfilerAgent_h
#define InspectorProfilerAgent_h

#include "core/CoreExport.h"
#include "core/InspectorFrontend.h"
#include "core/inspector/InspectorBaseAgent.h"
#include "wtf/Forward.h"
#include "wtf/Noncopyable.h"
#include "wtf/PassOwnPtr.h"
#include "wtf/text/WTFString.h"

namespace blink {

class ExecutionContext;
class InspectorFrontend;
class V8ProfilerAgent;

typedef String ErrorString;

class CORE_EXPORT InspectorProfilerAgent final : public InspectorBaseAgent<InspectorProfilerAgent, InspectorFrontend::Profiler>, public InspectorBackendDispatcher::ProfilerCommandHandler {
    WTF_MAKE_NONCOPYABLE(InspectorProfilerAgent);
    USING_FAST_MALLOC_WILL_BE_REMOVED(InspectorProfilerAgent);
public:
    class Client {
    public:
        virtual ~Client() { }
        virtual void profilingStarted() { }
        virtual void profilingStopped() { }
    };

    static PassOwnPtrWillBeRawPtr<InspectorProfilerAgent> create(v8::Isolate*, Client*);
    ~InspectorProfilerAgent() override;
    DECLARE_VIRTUAL_TRACE();

    // InspectorBaseAgent overrides.
    void init() override;
    void setFrontend(InspectorFrontend*) override;
    void clearFrontend() override;
    void restore() override;

    void consoleProfile(ExecutionContext*, const String& title);
    void consoleProfileEnd(const String& title);

    void enable(ErrorString*) override;
    void disable(ErrorString*) override;
    void setSamplingInterval(ErrorString*, int) override;
    void start(ErrorString*) override;
    void stop(ErrorString*, RefPtr<TypeBuilder::Profiler::CPUProfile>&) override;

    void willProcessTask();
    void didProcessTask();
    void willEnterNestedRunLoop();
    void didLeaveNestedRunLoop();

private:
    InspectorProfilerAgent(v8::Isolate*, Client*);

    Client* m_client;
    OwnPtr<V8ProfilerAgent> m_v8ProfilerAgent;
};

} // namespace blink

#endif // !defined(InspectorProfilerAgent_h)


text:
using node_webrtc::CreateOfferObserver;
using node_webrtc::PeerConnection;

void CreateOfferObserver::OnSuccess(webrtc::SessionDescriptionInterface* sdp) {
  TRACE_CALL;
  PeerConnection::SdpEvent* data = new PeerConnection::SdpEvent(sdp);
  parent->QueueEvent(PeerConnection::CREATE_OFFER_SUCCESS, static_cast<void*>(data));
  TRACE_END;
}

void CreateOfferObserver::OnFailure(const std::string& msg) {
  TRACE_CALL;
  PeerConnection::ErrorEvent* data = new PeerConnection::ErrorEvent(msg);
  parent->QueueEvent(PeerConnection::CREATE_OFFER_ERROR, static_cast<void*>(data));
  TRACE_END;
}


text:
<?php $this->managelayout->add_css(element('view_skin_url', $layout) . '/css/style.css'); ?>
<?php    $this->managelayout->add_js(base_url('plugin/zeroclipboard/ZeroClipboard.js')); ?>

<?php
if (element('syntax_highlighter', element('board', $view)) OR element('comment_syntax_highlighter', element('board', $view))) {
    $this->managelayout->add_css(base_url('assets/js/syntaxhighlighter/styles/shCore.css'));
    $this->managelayout->add_css(base_url('assets/js/syntaxhighlighter/styles/shThemeMidnight.css'));
    $this->managelayout->add_js(base_url('assets/js/syntaxhighlighter/scripts/shCore.js'));
    $this->managelayout->add_js(base_url('assets/js/syntaxhighlighter/scripts/shBrushJScript.js'));
    $this->managelayout->add_js(base_url('assets/js/syntaxhighlighter/scripts/shBrushPhp.js'));
    $this->managelayout->add_js(base_url('assets/js/syntaxhighlighter/scripts/shBrushCss.js'));
    $this->managelayout->add_js(base_url('assets/js/syntaxhighlighter/scripts/shBrushXml.js'));
?>

<?php } ?>

<?php echo element('headercontent', element('board', $view)); ?>

        <?php echo show_alert_message($this->session->flashdata('message'), '
<button type="button" class="close alertclose" >×</button>', '
'); ?>

            <?php if (element('category', element('post', $view))) { ?>[<?php echo html_escape(element('bca_value', element('category', element('post', $view)))); ?>] <?php } ?>
            <?php echo html_escape(element('post_title', element('post', $view))); ?>

                <?php echo element('post_datetime', element('post', $view)); ?>

        <?php if (element('extra_content', $view)) { ?>

                        <?php foreach (element('extra_content', $view) as $key => $value) { ?>

                                <?php echo html_escape(element('display_name', $value)); ?>
                                <?php echo nl2br(html_escape(element('output', $value))); ?>

                        <?php } ?>

        <?php } ?>

            <?php
            if (element('file_image', $view)) {
                foreach (element('file_image', $view) as $key => $value) {
            ?>
                <img src="<?php echo element('thumb_image_url', $value); ?>" alt="<?php echo html_escape(element('pfi_originname', $value)); ?>" title="<?php echo html_escape(element('pfi_originname', $value)); ?>" class="view_full_image" data-origin-image-url="<?php echo element('origin_image_url', $value); ?>" style="max-width:100%;" />
            <?php
                }
            }
            ?>

<?php echo element('content', element('post', $view)); ?>

        <?php if ( ! element('post_del', element('post', $view)) && (element('use_post_like', element('board', $view)) OR element('use_post_dislike', element('board', $view)))) { ?>

                <?php if (element('use_post_like', element('board', $view))) { ?>
                    <a class="good" href="javascript:;" id="btn-post-like" onClick="post_like('<?php echo element('post_id', element('post', $view)); ?>', '1', 'post-like');" title="추천하기"><?php echo number_format(element('post_like', element('post', $view))); ?>

                <?php } ?>
                <?php if (element('use_post_dislike', element('board', $view))) { ?>
                    <a class="bad" href="javascript:;" id="btn-post-dislike" onClick="post_like('<?php echo element('post_id', element('post', $view)); ?>', '2', 'post-dislike');" title="비추하기"><?php echo number_format(element('post_dislike', element('post', $view))); ?>

                <?php } ?>

        <?php } ?>

            <?php if ( ! element('post_del', element('post', $view)) && element('use_scrap', element('board', $view))) { ?>
                <button type="button" class="btn btn-black" id="btn-scrap" onClick="post_scrap('<?php echo element('post_id', element('post', $view)); ?>', 'post-scrap');">스크랩 <?php echo element('scrap_count', element('post', $view)) ? '+' . number_format(element('scrap_count', element('post', $view))) : ''; ?></button>
            <?php } ?>
            <?php if ( ! element('post_del', element('post', $view)) && element('use_blame', element('board', $view)) && ( ! element('blame_blind_count', element('board', $view)) OR element('post_blame', element('post', $view)) < element('blame_blind_count', element('board', $view)))) { ?>
                <button type="button" class="btn btn-black" id="btn-blame" onClick="post_blame('<?php echo element('post_id', element('post', $view)); ?>', 'post-blame');">신고 <?php echo element('post_blame', element('post', $view)) ? '+' . number_format(element('post_blame', element('post', $view))) : ''; ?></button>
            <?php } ?>

            <?php if ( ! element('post_del', element('post', $view)) && element('is_admin', $view)) { ?>
                <button type="button" class="btn btn-default btn-sm admin-manage-post">관리</button>

                    <?php if (element('is_admin', $view) === 'super') { ?>
                        <div class="item" onClick="post_copy('copy', '<?php echo element('post_id', element('post', $view)); ?>');"> 복사하기

                        <div class="item" onClick="post_copy('move', '<?php echo element('post_id', element('post', $view)); ?>');"> 이동하기

                        <?php if (element('use_category', element('board', $view))) { ?>
                            <div class="item" onClick="post_change_category('<?php echo element('post_id', element('post', $view)); ?>');"> 카테고리변경

                    <?php
                        }
                    }
                    if (element('use_post_secret', element('board', $view))) {
                        if (element('post_secret', element('post', $view))) {
                    ?>
                        <div class="item" onClick="post_action('post_secret', '<?php echo element('post_id', element('post', $view)); ?>', '0');"> 비밀글해제

                    <?php } else { ?>
                        <div class="item" onClick="post_action('post_secret', '<?php echo element('post_id', element('post', $view)); ?>', '1');"> 비밀글로

                    <?php
                        }
                    }
                    if (element('post_hide_comment', element('post', $view))) {
                    ?>
                        <div class="item" onClick="post_action('post_hide_comment', '<?php echo element('post_id', element('post', $view)); ?>', '0');"> 댓글감춤해제

                    <?php } else { ?>
                        <div class="item" onClick="post_action('post_hide_comment', '<?php echo element('post_id', element('post', $view)); ?>', '1');"> 댓글감춤

                    <?php } ?>
                    <?php if (element('post_notice', element('post', $view))) { ?>
                        <div class="item" onClick="post_action('post_notice', '<?php echo element('post_id', element('post', $view)); ?>', '0');"> 공지내림

                    <?php } else { ?>
                        <div class="item" onClick="post_action('post_notice', '<?php echo element('post_id', element('post', $view)); ?>', '1');"> 공지올림

                    <?php } ?>
                    <?php if (element('post_blame', element('post', $view)) >= element('blame_blind_count', element('board', $view))) { ?>
                        <div class="item" onClick="post_action('post_blame_blind', '<?php echo element('post_id', element('post', $view)); ?>', '0');"> 블라인드해제

                    <?php } else { ?>
                        <div class="item" onClick="post_action('post_blame_blind', '<?php echo element('post_id', element('post', $view)); ?>', '1');"> 블라인드처리

                    <?php } ?>
                    <div class="item" onClick="post_action('post_trash', '<?php echo element('post_id', element('post', $view)); ?>', '', '이 글을 휴지통으로 이동하시겠습니까?');"> 휴지통으로

            <?php } ?>

        <?php
        if (element('use_sns_button', $view)) {
            $this->managelayout->add_js(base_url('assets/js/sns.js'));

            if ($this->cbconfig->item('kakao_apikey')) {
                $this->managelayout->add_js('https://developers.kakao.com/sdk/js/kakao.min.js');
        ?>

            <?php } ?>

                <a href="javascript:;" onClick="sendSns('facebook', '<?php echo element('short_url', $view); ?>', '<?php echo html_escape(element('post_title', element('post', $view)));?>');" title="이 글을 페이스북으로 퍼가기"><img src="<?php echo element('view_skin_url', $layout); ?>/images/social_facebook.png" width="22" height="22" alt="이 글을 페이스북으로 퍼가기" title="이 글을 페이스북으로 퍼가기" />
                <a href="javascript:;" onClick="sendSns('twitter', '<?php echo element('short_url', $view); ?>', '<?php echo html_escape(element('post_title', element('post', $view)));?>');" title="이 글을 트위터로 퍼가기"><img src="<?php echo element('view_skin_url', $layout); ?>/images/social_twitter.png" width="22" height="22" alt="이 글을 트위터로 퍼가기" title="이 글을 트위터로 퍼가기" />
                <?php if ($this->cbconfig->item('kakao_apikey')) { ?>
                    <a href="javascript:;" onClick="kakaolink_send('<?php echo html_escape(element('post_title', element('post', $view)));?>', '<?php echo element('short_url', $view); ?>');" title="이 글을 카카오톡으로 퍼가기"><img src="<?php echo element('view_skin_url', $layout); ?>/images/social_kakaotalk.png" width="22" height="22" alt="이 글을 카카오톡으로 퍼가기" title="이 글을 카카오톡으로 퍼가기" />
                <?php } ?>
                <a href="javascript:;" onClick="sendSns('kakaostory', '<?php echo element('short_url', $view); ?>', '<?php echo html_escape(element('post_title', element('post', $view)));?>');" title="이 글을 카카오스토리로 퍼가기"><img src="<?php echo element('view_skin_url', $layout); ?>/images/social_kakaostory.png" width="22" height="22" alt="이 글을 카카오스토리로 퍼가기" title="이 글을 카카오스토리로 퍼가기" />
                <a href="javascript:;" onClick="sendSns('band', '<?php echo element('short_url', $view); ?>', '<?php echo html_escape(element('post_title', element('post', $view)));?>');" title="이 글을 밴드로 퍼가기"><img src="<?php echo element('view_skin_url', $layout); ?>/images/social_band.png" width="22" height="22" alt="이 글을 밴드로 퍼가기" title="이 글을 밴드로 퍼가기" />

        <?php } ?>

                <?php if (element('modify_url', $view)) { ?>
                    <a href="<?php echo element('modify_url', $view); ?>" class="btn btn-default btn-sm">수정
                <?php } ?>
                <?php    if (element('delete_url', $view)) { ?>
                    <button type="button" class="btn btn-default btn-sm btn-one-delete" data-one-delete-url="<?php echo element('delete_url', $view); ?>">삭제</button>
                <?php } ?>
                <a href="<?php echo element('list_url', $view); ?>" class="btn btn-default btn-sm">목록
                <?php if (element('search_list_url', $view)) { ?>
                    <a href="<?php echo element('search_list_url', $view); ?>" class="btn btn-default btn-sm">검색목록
                <?php } ?>
                <?php if (element('reply_url', $view)) { ?>
                    <a href="<?php echo element('reply_url', $view); ?>" class="btn btn-default btn-sm">답변
                <?php } ?>
                <?php if (element('prev_post', $view)) { ?>
                    <a href="<?php echo element('url', element('prev_post', $view)); ?>" class="btn btn-default btn-sm">이전글
                <?php } ?>
                <?php if (element('next_post', $view)) { ?>
                    <a href="<?php echo element('url', element('next_post', $view)); ?>" class="btn btn-default btn-sm">다음글
                <?php } ?>

<?php echo element('footercontent', element('board', $view)); ?>

<?php if (element('target_blank', element('board', $view))) { ?>

<?php } ?>

<?php
if (element('highlight_keyword', $view)) {
    $this->managelayout->add_js(base_url('assets/js/jquery.highlight.js'));
?>

<?php } ?>


text:
Padrino.configure_apps do
  # enable :sessions
  set :session_secret, '089aafd4d96b397be6d95127f969d51d026371d9e021b0f6360c0b105c5633f5'
  set :protection, :except => :path_traversal
  set :protect_from_csrf, true
end

# Mounts the core application for this project
Padrino.mount('BugsnagPadrino::App', :app_file => Padrino.root('app/app.rb')).to('/')


text:
cask 'osxfuse-dev' do
  version '3.8.2'
  sha256 '03a3e561803cdf9fa797c146dc33f0ec0d665cc2bf41cf2b68b3c5b34b03b758'

  # github.com/osxfuse was verified as official when first introduced to the cask
  url "https://github.com/osxfuse/osxfuse/releases/download/osxfuse-#{version}/osxfuse-#{version}.dmg"
  appcast 'https://github.com/osxfuse/osxfuse/releases.atom'
  name 'OSXFUSE'
  homepage 'https://osxfuse.github.io/'

  auto_updates true
  conflicts_with cask: 'osxfuse'

  pkg "Extras/FUSE for macOS #{version}.pkg",
      choices: [
                 'choiceIdentifier' => 'com.github.osxfuse.pkg.MacFUSE',
                 'choiceAttribute'  => 'selected',
                 'attributeSetting' => 1,
               ]

  postflight do
    set_ownership ['/usr/local/include', '/usr/local/lib']
  end

  uninstall pkgutil: [
                       'com.github.osxfuse.pkg.Core',
                       'com.github.osxfuse.pkg.MacFUSE',
                       'com.github.osxfuse.pkg.PrefPane',
                     ],
            kext:    'com.github.osxfuse.filesystems.osxfusefs'

  caveats do
    reboot
  end
end


text:
<?php

class swFormatterGMapAddress extends sfWidgetFormSchemaFormatter
{
  protected
    $rowFormat       = "%error%%label%\n  %field%%help%\n",
    $errorRowFormat  = "\n%errors%\n",
    $errorListFormatInARow     = "  \n%errors%  \n",
    $errorRowFormatInARow      = "  %error%\n",
    $helpFormat      = '
%help%',
    $decoratorFormat = "%content%";

}


text:
import  React from 'react'
import TextField from '@material-ui/core/TextField'

import { FsPopupType } from 'store/states/popupsState'
import { usePopups, useDirectoryCreation, useFilesystem } from 'store/store'

import Popup from 'components/utils/Popup'

const popupType: FsPopupType = 'DIRECTORY_CREATION'

function CreationPopup() {

  const [directoryName, setDirectoryName] = React.useState('')

  const { current } = useFilesystem()
  const { isPopupOpen, hidePopup } = usePopups()
  const { createDirectory, loading, error } = useDirectoryCreation()

  return (
    <Popup
      title="Créer un nouveau dossier"
      action="Créer le dossier"
      cancel="Annuler"
      error={error && error.errors && error.errors['path'] && error.errors['path'][0]}
      loading={loading }
      open={isPopupOpen(popupType)}
      onClose={hidePopup}
      onValidate={() => createDirectory(`${current ? current.path : ''}/${directoryName.trim()}`)}
    >
      <TextField
        autoFocus
        margin="dense"
        id="name"
        label="Nom dossier"
        type="text"
        disabled={loading}
        fullWidth
        onChange={(e) => setDirectoryName(e.target.value)}
        error={!!error}
      />
    </Popup>
  )
}

export default CreationPopup


text:
package com.github.coderplay.util.concurrent.queue;

/**
 * Holder class for a long value.
 */
public class MutableLong {
  private long value = 0L;

  /**
   * Default constructor
   */
  public MutableLong() {
  }

  /**
   * Construct the holder with initial value.
   *
   * @param initialValue to be initially set.
   */
  public MutableLong(final long initialValue) {
    this.value = initialValue;
  }

  /**
   * Get the long value.
   *
   * @return the long value.
   */
  public long get() {
    return value;
  }

  /**
   * Set the long value.
   *
   * @param value to set.
   */
  public void set(final long value) {
    this.value = value;
  }
}


text:
#include "database/proxy/DBObject.h"
#include "database/proxy/LoginnTypes.h"

class DELOPRSQL_API Loginn : public DBObject
{
public:
	Loginn(){}

	tSQLResult Read		(LoginnReadStruct& data);
};


text:
package org.elasticsearch.common.settings;

import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.elasticsearch.ElasticSearchIllegalArgumentException;
import org.elasticsearch.Version;
import org.elasticsearch.common.Booleans;
import org.elasticsearch.common.Classes;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.io.Streams;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.property.PropertyPlaceholder;
import org.elasticsearch.common.settings.loader.SettingsLoader;
import org.elasticsearch.common.settings.loader.SettingsLoaderFactory;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.unit.SizeValue;
import org.elasticsearch.common.unit.TimeValue;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.*;
import java.util.concurrent.TimeUnit;

import static org.elasticsearch.common.Strings.toCamelCase;
import static org.elasticsearch.common.unit.ByteSizeValue.parseBytesSizeValue;
import static org.elasticsearch.common.unit.SizeValue.parseSizeValue;
import static org.elasticsearch.common.unit.TimeValue.parseTimeValue;

/**
 * An immutable implementation of {@link Settings}.
 */
public class ImmutableSettings implements Settings {

    public static final Settings EMPTY = new Builder().build();

    private ImmutableMap<String, String> settings;
    private transient ClassLoader classLoader;

    ImmutableSettings(Map<String, String> settings, ClassLoader classLoader) {
        this.settings = ImmutableMap.copyOf(settings);
        this.classLoader = classLoader;
    }

    @Override
    public ClassLoader getClassLoader() {
        return this.classLoader == null ? Classes.getDefaultClassLoader() : classLoader;
    }

    @Override
    public ClassLoader getClassLoaderIfSet() {
        return this.classLoader;
    }

    @Override
    public ImmutableMap<String, String> getAsMap() {
        return this.settings;
    }

    @Override
    public Settings getComponentSettings(Class component) {
        if (component.getName().startsWith("org.elasticsearch")) {
            return getComponentSettings("org.elasticsearch", component);
        }
        // not starting with org.elasticsearch, just remove the first package part (probably org/net/com)
        return getComponentSettings(component.getName().substring(0, component.getName().indexOf('.')), component);
    }

    @Override
    public Settings getComponentSettings(String prefix, Class component) {
        String type = component.getName();
        if (!type.startsWith(prefix)) {
            throw new SettingsException("Component [" + type + "] does not start with prefix [" + prefix + "]");
        }
        String settingPrefix = type.substring(prefix.length() + 1); // 1 for the '.'
        settingPrefix = settingPrefix.substring(0, settingPrefix.length() - component.getSimpleName().length()); // remove the simple class name (keep the dot)
        return getByPrefix(settingPrefix);
    }

    @Override
    public Settings getByPrefix(String prefix) {
        Builder builder = new Builder();
        for (Map.Entry<String, String> entry : getAsMap().entrySet()) {
            if (entry.getKey().startsWith(prefix)) {
                if (entry.getKey().length() < prefix.length()) {
                    // ignore this one
                    continue;
                }
                builder.put(entry.getKey().substring(prefix.length()), entry.getValue());
            }
        }
        builder.classLoader(classLoader);
        return builder.build();
    }

    @Override
    public String get(String setting) {
        String retVal = settings.get(setting);
        if (retVal != null) {
            return retVal;
        }
        // try camel case version
        return settings.get(toCamelCase(setting));
    }

    @Override
    public String get(String[] settings) {
        for (String setting : settings) {
            String retVal = this.settings.get(setting);
            if (retVal != null) {
                return retVal;
            }
            retVal = this.settings.get(toCamelCase(setting));
            if (retVal != null) {
                return retVal;
            }
        }
        return null;
    }

    @Override
    public String get(String setting, String defaultValue) {
        String retVal = get(setting);
        return retVal == null ? defaultValue : retVal;
    }

    @Override
    public String get(String[] settings, String defaultValue) {
        String retVal = get(settings);
        return retVal == null ? defaultValue : retVal;
    }

    @Override
    public Float getAsFloat(String setting, Float defaultValue) {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Float.parseFloat(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse float setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Float getAsFloat(String[] settings, Float defaultValue) throws SettingsException {
        String sValue = get(settings);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Float.parseFloat(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse float setting [" + Arrays.toString(settings) + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Double getAsDouble(String setting, Double defaultValue) {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Double.parseDouble(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse double setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Double getAsDouble(String[] settings, Double defaultValue) {
        String sValue = get(settings);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Double.parseDouble(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse double setting [" + Arrays.toString(settings) + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Integer getAsInt(String setting, Integer defaultValue) {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse int setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Integer getAsInt(String[] settings, Integer defaultValue) {
        String sValue = get(settings);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse int setting [" + Arrays.toString(settings) + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Long getAsLong(String setting, Long defaultValue) {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Long.parseLong(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse long setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Long getAsLong(String[] settings, Long defaultValue) {
        String sValue = get(settings);
        if (sValue == null) {
            return defaultValue;
        }
        try {
            return Long.parseLong(sValue);
        } catch (NumberFormatException e) {
            throw new SettingsException("Failed to parse long setting [" + Arrays.toString(settings) + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public Boolean getAsBoolean(String setting, Boolean defaultValue) {
        return Booleans.parseBoolean(get(setting), defaultValue);
    }

    @Override
    public Boolean getAsBoolean(String[] settings, Boolean defaultValue) {
        return Booleans.parseBoolean(get(settings), defaultValue);
    }

    @Override
    public TimeValue getAsTime(String setting, TimeValue defaultValue) {
        return parseTimeValue(get(setting), defaultValue);
    }

    @Override
    public TimeValue getAsTime(String[] settings, TimeValue defaultValue) {
        return parseTimeValue(get(settings), defaultValue);
    }

    @Override
    public ByteSizeValue getAsBytesSize(String setting, ByteSizeValue defaultValue) throws SettingsException {
        return parseBytesSizeValue(get(setting), defaultValue);
    }

    @Override
    public ByteSizeValue getAsBytesSize(String[] settings, ByteSizeValue defaultValue) throws SettingsException {
        return parseBytesSizeValue(get(settings), defaultValue);
    }

    @Override
    public SizeValue getAsSize(String setting, SizeValue defaultValue) throws SettingsException {
        return parseSizeValue(get(setting), defaultValue);
    }

    @Override
    public SizeValue getAsSize(String[] settings, SizeValue defaultValue) throws SettingsException {
        return parseSizeValue(get(settings), defaultValue);
    }

    @SuppressWarnings({"unchecked"})
    @Override
    public <T> Class<? extends T> getAsClass(String setting, Class<? extends T> defaultClazz) throws NoClassSettingsException {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultClazz;
        }
        try {
            return (Class<? extends T>) getClassLoader().loadClass(sValue);
        } catch (ClassNotFoundException e) {
            throw new NoClassSettingsException("Failed to load class setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @SuppressWarnings({"unchecked"})
    @Override
    public <T> Class<? extends T> getAsClass(String setting, Class<? extends T> defaultClazz, String prefixPackage, String suffixClassName) throws NoClassSettingsException {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultClazz;
        }
        String fullClassName = sValue;
        try {
            return (Class<? extends T>) getClassLoader().loadClass(fullClassName);
        } catch (ClassNotFoundException e) {
            String prefixValue = prefixPackage;
            int packageSeparator = sValue.lastIndexOf('.');
            if (packageSeparator > 0) {
                prefixValue = sValue.substring(0, packageSeparator + 1);
                sValue = sValue.substring(packageSeparator + 1);
            }
            fullClassName = prefixValue + Strings.capitalize(toCamelCase(sValue)) + suffixClassName;
            try {
                return (Class<? extends T>) getClassLoader().loadClass(fullClassName);
            } catch (ClassNotFoundException e1) {
                return loadClass(prefixValue, sValue, suffixClassName, setting);
            } catch (NoClassDefFoundError e1) {
                return loadClass(prefixValue, sValue, suffixClassName, setting);
            }
        }
    }

    private <T> Class<? extends T> loadClass(String prefixValue, String sValue, String suffixClassName, String setting) {
        String fullClassName = prefixValue + toCamelCase(sValue).toLowerCase(Locale.ROOT) + "." + Strings.capitalize(toCamelCase(sValue)) + suffixClassName;
        try {
            return (Class<? extends T>) getClassLoader().loadClass(fullClassName);
        } catch (ClassNotFoundException e2) {
            throw new NoClassSettingsException("Failed to load class setting [" + setting + "] with value [" + get(setting) + "]", e2);
        }
    }

    @Override
    public String[] getAsArray(String settingPrefix) throws SettingsException {
        return getAsArray(settingPrefix, Strings.EMPTY_ARRAY, true);
    }

    @Override
    public String[] getAsArray(String settingPrefix, String[] defaultArray) throws SettingsException {
        return getAsArray(settingPrefix, defaultArray, true);
    }

    @Override
    public String[] getAsArray(String settingPrefix, String[] defaultArray, Boolean commaDelimited) throws SettingsException {
        List<String> result = Lists.newArrayList();

        if (get(settingPrefix) != null) {
            if (commaDelimited) {
                String[] strings = Strings.splitStringByCommaToArray(get(settingPrefix));
                if (strings.length > 0) {
                    for (String string : strings) {
                        result.add(string.trim());
                    }
                }
            } else {
                result.add(get(settingPrefix).trim());
            }
        }

        int counter = 0;
        while (true) {
            String value = get(settingPrefix + '.' + (counter++));
            if (value == null) {
                break;
            }
            result.add(value.trim());
        }
        if (result.isEmpty()) {
            return defaultArray;
        }
        return result.toArray(new String[result.size()]);
    }

    @Override
    public Map<String, Settings> getGroups(String settingPrefix) throws SettingsException {
        if (settingPrefix.charAt(settingPrefix.length() - 1) != '.') {
            settingPrefix = settingPrefix + ".";
        }
        // we don't really care that it might happen twice
        Map<String, Map<String, String>> map = new LinkedHashMap<String, Map<String, String>>();
        for (Object o : settings.keySet()) {
            String setting = (String) o;
            if (setting.startsWith(settingPrefix)) {
                String nameValue = setting.substring(settingPrefix.length());
                int dotIndex = nameValue.indexOf('.');
                if (dotIndex == -1) {
                    throw new SettingsException("Failed to get setting group for [" + settingPrefix + "] setting prefix and setting [" + setting + "] because of a missing '.'");
                }
                String name = nameValue.substring(0, dotIndex);
                String value = nameValue.substring(dotIndex + 1);
                Map<String, String> groupSettings = map.get(name);
                if (groupSettings == null) {
                    groupSettings = new LinkedHashMap<String, String>();
                    map.put(name, groupSettings);
                }
                groupSettings.put(value, get(setting));
            }
        }
        Map<String, Settings> retVal = new LinkedHashMap<String, Settings>();
        for (Map.Entry<String, Map<String, String>> entry : map.entrySet()) {
            retVal.put(entry.getKey(), new ImmutableSettings(Collections.unmodifiableMap(entry.getValue()), classLoader));
        }
        return Collections.unmodifiableMap(retVal);
    }

    @Override
    public Version getAsVersion(String setting, Version defaultVersion) throws SettingsException {
        String sValue = get(setting);
        if (sValue == null) {
            return defaultVersion;
        }
        try {
            return Version.fromId(Integer.parseInt(sValue));
        } catch (Exception e) {
            throw new SettingsException("Failed to parse version setting [" + setting + "] with value [" + sValue + "]", e);
        }
    }

    @Override
    public String toDelimitedString(char delimiter) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : settings.entrySet()) {
            sb.append(entry.getKey()).append("=").append(entry.getValue()).append(delimiter);
        }
        return sb.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ImmutableSettings that = (ImmutableSettings) o;

        if (classLoader != null ? !classLoader.equals(that.classLoader) : that.classLoader != null) return false;
        if (settings != null ? !settings.equals(that.settings) : that.settings != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = settings != null ? settings.hashCode() : 0;
        result = 31 * result + (classLoader != null ? classLoader.hashCode() : 0);
        return result;
    }

    public static Settings readSettingsFromStream(StreamInput in) throws IOException {
        Builder builder = new Builder();
        int numberOfSettings = in.readVInt();
        for (int i = 0; i < numberOfSettings; i++) {
            builder.put(in.readString(), in.readString());
        }
        return builder.build();
    }

    public static void writeSettingsToStream(Settings settings, StreamOutput out) throws IOException {
        out.writeVInt(settings.getAsMap().size());
        for (Map.Entry<String, String> entry : settings.getAsMap().entrySet()) {
            out.writeString(entry.getKey());
            out.writeString(entry.getValue());
        }
    }

    public static Builder builder() {
        return new Builder();
    }

    /**
     * Returns a builder to be used in order to build settings.
     */
    public static Builder settingsBuilder() {
        return new Builder();
    }

    /**
     * A builder allowing to put different settings and then {@link #build()} an immutable
     * settings implementation. Use {@link ImmutableSettings#settingsBuilder()} in order to
     * construct it.
     */
    public static class Builder implements Settings.Builder {

        public static final Settings EMPTY_SETTINGS = new Builder().build();

        private final Map<String, String> map = new LinkedHashMap<String, String>();

        private ClassLoader classLoader;

        private Builder() {

        }

        public Map<String, String> internalMap() {
            return this.map;
        }

        /**
         * Removes the provided setting from the internal map holding the current list of settings.
         */
        public String remove(String key) {
            return map.remove(key);
        }

        /**
         * Returns a setting value based on the setting key.
         */
        public String get(String key) {
            String retVal = map.get(key);
            if (retVal != null) {
                return retVal;
            }
            // try camel case version
            return map.get(toCamelCase(key));
        }

        /**
         * Puts tuples of key value pairs of settings. Simplified version instead of repeating calling
         * put for each one.
         */
        public Builder put(Object... settings) {
            if (settings.length == 1) {
                // support cases where the actual type gets lost down the road...
                if (settings[0] instanceof Map) {
                    //noinspection unchecked
                    return put((Map) settings[0]);
                } else if (settings[0] instanceof Settings) {
                    return put((Settings) settings[0]);
                }
            }
            if ((settings.length % 2) != 0) {
                throw new ElasticSearchIllegalArgumentException("array settings of key + value order doesn't hold correct number of arguments (" + settings.length + ")");
            }
            for (int i = 0; i < settings.length; i++) {
                put(settings[i++].toString(), settings[i].toString());
            }
            return this;
        }

        /**
         * Sets a setting with the provided setting key and value.
         *
         * @param key   The setting key
         * @param value The setting value
         * @return The builder
         */
        public Builder put(String key, String value) {
            map.put(key, value);
            return this;
        }

        /**
         * Sets a setting with the provided setting key and class as value.
         *
         * @param key   The setting key
         * @param clazz The setting class value
         * @return The builder
         */
        public Builder put(String key, Class clazz) {
            map.put(key, clazz.getName());
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the boolean value.
         *
         * @param setting The setting key
         * @param value   The boolean value
         * @return The builder
         */
        public Builder put(String setting, boolean value) {
            put(setting, String.valueOf(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the int value.
         *
         * @param setting The setting key
         * @param value   The int value
         * @return The builder
         */
        public Builder put(String setting, int value) {
            put(setting, String.valueOf(value));
            return this;
        }

        public Builder put(String setting, Version version) {
            put(setting, version.id);
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the long value.
         *
         * @param setting The setting key
         * @param value   The long value
         * @return The builder
         */
        public Builder put(String setting, long value) {
            put(setting, String.valueOf(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the float value.
         *
         * @param setting The setting key
         * @param value   The float value
         * @return The builder
         */
        public Builder put(String setting, float value) {
            put(setting, String.valueOf(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the double value.
         *
         * @param setting The setting key
         * @param value   The double value
         * @return The builder
         */
        public Builder put(String setting, double value) {
            put(setting, String.valueOf(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the time value.
         *
         * @param setting The setting key
         * @param value   The time value
         * @return The builder
         */
        public Builder put(String setting, long value, TimeUnit timeUnit) {
            put(setting, timeUnit.toMillis(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and the size value.
         *
         * @param setting The setting key
         * @param value   The size value
         * @return The builder
         */
        public Builder put(String setting, long value, ByteSizeUnit sizeUnit) {
            put(setting, sizeUnit.toBytes(value));
            return this;
        }

        /**
         * Sets the setting with the provided setting key and an array of values.
         *
         * @param setting The setting key
         * @param values  The values
         * @return The builder
         */
        public Builder putArray(String setting, String... values) {
            remove(setting);
            int counter = 0;
            while (true) {
                String value = map.remove(setting + '.' + (counter++));
                if (value == null) {
                    break;
                }
            }
            for (int i = 0; i < values.length; i++) {
                put(setting + "." + i, values[i]);
            }
            return this;
        }

        /**
         * Sets the setting group.
         */
        public Builder put(String settingPrefix, String groupName, String[] settings, String[] values) throws SettingsException {
            if (settings.length != values.length) {
                throw new SettingsException("The settings length must match the value length");
            }
            for (int i = 0; i < settings.length; i++) {
                if (values[i] == null) {
                    continue;
                }
                put(settingPrefix + "." + groupName + "." + settings[i], values[i]);
            }
            return this;
        }

        /**
         * Sets all the provided settings.
         */
        public Builder put(Settings settings) {
            map.putAll(settings.getAsMap());
            classLoader = settings.getClassLoaderIfSet();
            return this;
        }

        /**
         * Sets all the provided settings.
         */
        public Builder put(Map<String, String> settings) {
            map.putAll(settings);
            return this;
        }

        /**
         * Sets all the provided settings.
         */
        public Builder put(Properties properties) {
            for (Map.Entry entry : properties.entrySet()) {
                map.put((String) entry.getKey(), (String) entry.getValue());
            }
            return this;
        }

        public Builder loadFromDelimitedString(String value, char delimiter) {
            String[] values = Strings.splitStringToArray(value, delimiter);
            for (String s : values) {
                int index = s.indexOf('=');
                if (index == -1) {
                    throw new ElasticSearchIllegalArgumentException("value [" + s + "] for settings loaded with delimiter [" + delimiter + "] is malformed, missing =");
                }
                map.put(s.substring(0, index), s.substring(index + 1));
            }
            return this;
        }

        /**
         * Loads settings from the actual string content that represents them using the
         * {@link SettingsLoaderFactory#loaderFromSource(String)}.
         */
        public Builder loadFromSource(String source) {
            SettingsLoader settingsLoader = SettingsLoaderFactory.loaderFromSource(source);
            try {
                Map<String, String> loadedSettings = settingsLoader.load(source);
                put(loadedSettings);
            } catch (Exception e) {
                throw new SettingsException("Failed to load settings from [" + source + "]", e);
            }
            return this;
        }

        /**
         * Loads settings from a url that represents them using the
         * {@link SettingsLoaderFactory#loaderFromSource(String)}.
         */
        public Builder loadFromUrl(URL url) throws SettingsException {
            try {
                return loadFromStream(url.toExternalForm(), url.openStream());
            } catch (IOException e) {
                throw new SettingsException("Failed to open stream for url [" + url.toExternalForm() + "]", e);
            }
        }

        /**
         * Loads settings from a stream that represents them using the
         * {@link SettingsLoaderFactory#loaderFromSource(String)}.
         */
        public Builder loadFromStream(String resourceName, InputStream is) throws SettingsException {
            SettingsLoader settingsLoader = SettingsLoaderFactory.loaderFromResource(resourceName);
            try {
                Map<String, String> loadedSettings = settingsLoader.load(Streams.copyToString(new InputStreamReader(is, Charsets.UTF_8)));
                put(loadedSettings);
            } catch (Exception e) {
                throw new SettingsException("Failed to load settings from [" + resourceName + "]", e);
            }
            return this;
        }

        /**
         * Loads settings from classpath that represents them using the
         * {@link SettingsLoaderFactory#loaderFromSource(String)}.
         */
        public Builder loadFromClasspath(String resourceName) throws SettingsException {
            ClassLoader classLoader = this.classLoader;
            if (classLoader == null) {
                classLoader = Classes.getDefaultClassLoader();
            }
            InputStream is = classLoader.getResourceAsStream(resourceName);
            if (is == null) {
                return this;
            }

            return loadFromStream(resourceName, is);
        }

        /**
         * Sets the class loader associated with the settings built.
         */
        public Builder classLoader(ClassLoader classLoader) {
            this.classLoader = classLoader;
            return this;
        }

        /**
         * Puts all the properties with keys starting with the provided <tt>prefix</tt>.
         *
         * @param prefix     The prefix to filter property key by
         * @param properties The properties to put
         * @return The builder
         */
        public Builder putProperties(String prefix, Properties properties) {
            for (Object key1 : properties.keySet()) {
                String key = (String) key1;
                String value = properties.getProperty(key);
                if (key.startsWith(prefix)) {
                    map.put(key.substring(prefix.length()), value);
                }
            }
            return this;
        }

        /**
         * Puts all the properties with keys starting with the provided <tt>prefix</tt>.
         *
         * @param prefix     The prefix to filter property key by
         * @param properties The properties to put
         * @return The builder
         */
        public Builder putProperties(String prefix, Properties properties, String[] ignorePrefixes) {
            for (Object key1 : properties.keySet()) {
                String key = (String) key1;
                String value = properties.getProperty(key);
                if (key.startsWith(prefix)) {
                    boolean ignore = false;
                    for (String ignorePrefix : ignorePrefixes) {
                        if (key.startsWith(ignorePrefix)) {
                            ignore = true;
                            break;
                        }
                    }
                    if (!ignore) {
                        map.put(key.substring(prefix.length()), value);
                    }
                }
            }
            return this;
        }

        /**
         * Runs across all the settings set on this builder and replaces <tt>${...}</tt> elements in the
         * each setting value according to the following logic:
         * <p/>
         * <p>First, tries to resolve it against a System property ({@link System#getProperty(String)}), next,
         * tries and resolve it against an environment variable ({@link System#getenv(String)}), and last, tries
         * and replace it with another setting already set on this builder.
         */
        public Builder replacePropertyPlaceholders() {
            PropertyPlaceholder propertyPlaceholder = new PropertyPlaceholder("${", "}", false);
            PropertyPlaceholder.PlaceholderResolver placeholderResolver = new PropertyPlaceholder.PlaceholderResolver() {
                @Override
                public String resolvePlaceholder(String placeholderName) {
                    if (placeholderName.startsWith("env.")) {
                        // explicit env var prefix
                        return System.getenv(placeholderName.substring("env.".length()));
                    }
                    String value = System.getProperty(placeholderName);
                    if (value != null) {
                        return value;
                    }
                    value = System.getenv(placeholderName);
                    if (value != null) {
                        return value;
                    }
                    return map.get(placeholderName);
                }

                @Override
                public boolean shouldIgnoreMissing(String placeholderName) {
                    // if its an explicit env var, we are ok with not having a value for it and treat it as optional
                    if (placeholderName.startsWith("env.")) {
                        return true;
                    }
                    return false;
                }
            };
            for (Map.Entry<String, String> entry : Maps.newHashMap(map).entrySet()) {
                String value = propertyPlaceholder.replacePlaceholders(entry.getValue(), placeholderResolver);
                // if the values exists and has length, we should maintain it  in the map
                // otherwise, the replace process resolved into removing it
                if (Strings.hasLength(value)) {
                    map.put(entry.getKey(), value);
                } else {
                    map.remove(entry.getKey());
                }
            }
            return this;
        }

        /**
         * Builds a {@link Settings} (underlying uses {@link ImmutableSettings}) based on everything
         * set on this builder.
         */
        public Settings build() {
            return new ImmutableSettings(Collections.unmodifiableMap(map), classLoader);
        }
    }
}


text:
Event::Event(std::string n, std::string d) {
	name = n;
	description = d;
}

Event::~Event(){}

void Event::getAttributes() {
	std::cout << "Name: " << name << std::endl;
	std::cout << "Description: " << description << std::endl;
}

std::string Event::getType()
{
	return name;
}