text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Curriculum Vitae LUIS CLEMENTE GONZALEZ</title>
    <meta name="description" content="">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link rel="stylesheet" href="css/normalize.css">
    <link rel="stylesheet" href="css/main.css">

Inicio

Datos Personales

Formación

Experiencia Profesional

Mis web

Nombre: Luis Clemente González

N.I.F.: 3.846.784-B

Fecha de nacimiento: 7 de Noviembre de 1970

Domicilio: C/ Orden del Temple, 15 45700 CONSUEGRA (Toledo)

Carnet de conducir: B1 Coche propio: Si

Email: luisclemen@gmail.com

Teléfono de contacto: 655 877 058

Técnico Especialista rama Administrativo y Comercial. I.E.S. CONSABURUM (Consuegra -Año 1990)

Informática Aplicada de Gestión. Ministerio de Trabajo y Seguridad Social

Programador de Gestión. Centro de Estudios Empresariales e Informáticos de Toledo.

Programador de Sistemas. Centro de Estudios Empresariales e Informáticos de Toledo.

Master en Informática. Centro de Estudios Empresariales e Informáticos de Toledo.

Curso de Metodología Didáctica. Ministerio de Trabajo y Seguridad Social

Sistemas operativos. MS-DOS, Windows XP / 2000 / 7 / 8

Metodología de la programación.

Paquetes de Aplicación. Office 2007 / 2010 / 2013, CMS Wordpress.

Microinformática.Reparación y configuracion de PC

Diseño Gráfico.

Internet. Protocolo TCP/IP, HTML5, CSS, Javascript, JQuery, PHP, Wordpress

Inglés. Hablado y escrito nivel básico.

Desarrollo de labores administrativas en el Estudio de Proyectos Industriales Pablo Sanz Revilla. (Año 1993)

Docencia en áreas de informática del curso Aplicaciones Informáticas de Oficina. Impartido por el Ministerio de Trabajo y Seguridad Social (INEM) en el Centro Cultural Cardenal Cisneros de Toledo. (Año 1993)

Docencia del curso Ofimática y entorno D.O.S. impartido por la Cámara de Comercio e Industria de Toledo y celebrado en la localidad de Puebla de Montalbán (TO). (Año 1994)

Labores propias derivadas de las funciones de Encargado de Tienda en la delegación que posee la empresa JUMP ORDENADORES S.L. en la ciudad de Toledo así como trabajo de calle visitando PYME y particulares para ayudar a la integración del producto y facilitar la venta final. (Año 1994 a 1998)

Desarrollo de labores propias de entrevistador trabajando para el Centro de Investigaciones Sociológicas (C.I.S.). (Año 1999)

Desarrollo de labores propias de agente comercial en la empresa PROCOMTEL, S.L. dedicada a la contratación de líneas de empresa de los distintos operadores telefónicos (Jazztel, British Telecom y Retevisión), así como planes Renove de centralitas y Planes de Empresa del operador telefónico móvil AMENA. (Año 1999)

Labores propias de agente comercial en la empresa MERCHANS TELECOMUNICACIONES, dedicada a la contratación de líneas de telefonía móvil para empresas y autónomos del operador AMENA, así como a la contratación de líneas de empresa de los distintos operadores de telefonía fija disponibles en España (Jazztel, Retevisión y British Telecom). (Año 2000)

Desarrollo de labores propias de comercial en la empresa MECANOGRAFICA SANTABÁRBARA S.L., dedicada a la venta de microinformática, mobiliario de oficina y todo material relacionado con la oficina (fotocopiadoras, ensobradoras, guillotinas, duplicadoras, etc.) (Marzo 2000 – Marzo 2012).

www.pizzeriamichelangelo.es

www.reformaslumbreras.es

www.touchezaragoza.es

Facebook

Google +

Twitter

LinkEdin

GitHub

redpajama_set_name: RedPajamaGithub


text:
#include <modules/webbrowser/interaction/cefinteractionhandler.h>
#include <modules/webbrowser/interaction/cefkeyboardmapping.h>
#include <modules/webbrowser/renderhandlergl.h>
#include <inviwo/core/interaction/events/pickingevent.h>
#include <inviwo/core/interaction/events/resizeevent.h>
#include <inviwo/core/interaction/events/wheelevent.h>
#include <inviwo/core/interaction/events/touchevent.h>

#include <iostream>
#include <string>
#include <locale>
#include <codecvt>

namespace inviwo {

CEFInteractionHandler::CEFInteractionHandler(CefRefPtr<CefBrowserHost> host) : host_(host){};

void CEFInteractionHandler::invokeEvent(Event* event) {
    switch (event->hash()) {
        case ResizeEvent::chash(): {
            auto resizeEvent = static_cast<ResizeEvent*>(event);
            renderHandler_->updateCanvasSize(resizeEvent->size());
            host_->WasResized();
            break;
        }
        case KeyboardEvent::chash(): {
            auto keyEvent = event->getAs<KeyboardEvent>();
            auto cefEvent = mapKeyEvent(keyEvent);
            host_->SendKeyEvent(cefEvent);
            // Send CHAR event for characters, but not non-char keys like arrows,
            // function keys or clear.
            auto isCharacter = std::iscntrl(cefEvent.character) == 0;
            if (isCharacter && (keyEvent->state() & KeyState::Press)) {
                cefEvent.type = KEYEVENT_CHAR;
                host_->SendKeyEvent(cefEvent);
            }
            event->markAsUsed();
            break;
        }
    }
}

void CEFInteractionHandler::handlePickingEvent(PickingEvent* p) {
    if (p->getEvent()->hash() == MouseEvent::chash()) {
        auto mouseEvent = p->getEventAs<MouseEvent>();
        updateMouseStates(mouseEvent);
        auto cefMouseEvent = mapMouseEvent(mouseEvent);
        if (mouseEvent->state() & MouseState::Move) {
            bool mouseLeave = false;
            host_->SendMouseMoveEvent(cefMouseEvent, mouseLeave);
            p->markAsUsed();
        } else if (mouseEvent->state() & MouseState::Press ||
                   mouseEvent->state() & MouseState::Release) {
            CefBrowserHost::MouseButtonType type;

            if (mouseEvent->button() & MouseButton::Left) {
                type = MBT_LEFT;
            } else if (mouseEvent->button() & MouseButton::Middle) {
                type = MBT_MIDDLE;
            } else {  // if (mouseEvent->button() & MouseButton::Right) {
                type = MBT_RIGHT;
            }
            bool mouseUp = MouseState::Release & mouseEvent->state() ? true : false;
            int clickCount = MouseState::DoubleClick & mouseEvent->state() ? 2 : 1;
            host_->SendMouseClickEvent(cefMouseEvent, type, mouseUp, clickCount);
            p->markAsUsed();
        }
    } else if (auto touchEvent = p->getEventAs<TouchEvent>()) {

        if (!touchEvent->hasTouchPoints()) {
            return;
        }
        TouchDevice::DeviceType type = touchEvent->getDevice()
                                           ? touchEvent->getDevice()->getType()
                                           : TouchDevice::DeviceType::TouchScreen;
        if (type == TouchDevice::DeviceType::TouchPad) {
            // Mouse events are emulated on touch pads for single touch point
            // but we need still need to consume multi-touch events if user pressed on
            p->markAsUsed();
            return;
        }
        const auto& touchPoints = touchEvent->touchPoints();
        updateMouseStates(touchEvent);
        // Only single touch point is currently supported
        const auto& activeTouchPoint = touchPoints[0];
        TouchStates moveState = (TouchState::Updated | TouchState::Stationary);
        TouchStates pressState = (TouchState::Started | TouchState::Finished);

        auto cefEvent = mapTouchEvent(&activeTouchPoint);
        if (activeTouchPoint.state() & moveState) {
            bool mouseLeave = false;
            host_->SendMouseMoveEvent(cefEvent, mouseLeave);
            p->markAsUsed();
        } else if (activeTouchPoint.state() & pressState) {
            // Emulate mouse press
            CefBrowserHost::MouseButtonType button;
            button = MBT_LEFT;
            bool mouseUp = activeTouchPoint.state() & (TouchState::Finished) ? true : false;
            int clickCount = 1;
            host_->SendMouseClickEvent(cefEvent, button, mouseUp, clickCount);
            p->markAsUsed();
        }
    } else if (auto wheelEvent = p->getEventAs<WheelEvent>()) {
        auto cefMouseEvent = mapMouseEvent(wheelEvent);
        host_->SendMouseWheelEvent(cefMouseEvent, static_cast<int>(wheelEvent->delta().x),
                                   static_cast<int>(wheelEvent->delta().y));
        p->markAsUsed();
    }
}

CefMouseEvent CEFInteractionHandler::mapMouseEvent(const MouseInteractionEvent* e) {
    CefMouseEvent cefEvent;
    cefEvent.x = static_cast<int>(e->x());
    cefEvent.y = static_cast<int>(e->canvasSize().y) - static_cast<int>(e->y());
    cefEvent.modifiers = modifiers_;
    return cefEvent;
}

CefMouseEvent CEFInteractionHandler::mapTouchEvent(const TouchPoint* p) {
    CefMouseEvent cefEvent;
    cefEvent.x = static_cast<int>(p->pos().x);
    cefEvent.y = static_cast<int>(p->canvasSize().y) - static_cast<int>(p->pos().y);
    cefEvent.modifiers = modifiers_;
    return cefEvent;
}

CefKeyEvent CEFInteractionHandler::mapKeyEvent(const KeyboardEvent* e) {
    CefKeyEvent cefEvent;

    // TODO: Fix key code translation to match the ones used in CEF
    // cefEvent.type = e->state() & KeyState::Press ? KEYEVENT_RAWKEYDOWN : KEYEVENT_CHAR;
    cefEvent.type = e->state() & KeyState::Press ? KEYEVENT_KEYDOWN : KEYEVENT_KEYUP;
    // Convert character to UTF16
#if _MSC_VER
    // Linker error when using char16_t in visual studio
    // https://social.msdn.microsoft.com/Forums/vstudio/en-US/8f40dcd8-c67f-4eba-9134-a19b9178e481/vs-2015-rc-linker-stdcodecvt-error?forum=vcgeneral
    auto textUTF16 = std::wstring_convert<std::codecvt_utf8_utf16<uint16_t>, uint16_t>{}.from_bytes(
        e->text().data());
#else
    auto textUTF16 = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(
        e->text().data());
#endif

    if (textUTF16.length() > 0) {
        cefEvent.character = textUTF16[0];
    } else {
        cefEvent.character = 0;
    }

    cefEvent.native_key_code = e->getNativeVirtualKey();

#ifdef _WINDOWS
    // F10 or ALT
    // https://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx
    cefEvent.is_system_key = (e->key() == IvwKey::F10) || (e->modifiers() & KeyModifier::Alt);
#else
    // Always false on non-windows platforms
    cefEvent.is_system_key = false;
#endif
    if (e->state() & KeyState::Press) {
        modifiers_ |= cef::keyModifiers(e->modifiers(), e->key());
    } else {
        modifiers_ &= ~cef::keyModifiers(e->modifiers(), e->key());
    }
    cefEvent.modifiers = modifiers_;
    return cefEvent;
}

void CEFInteractionHandler::updateMouseStates(MouseEvent* e) {
    if (e->state() & MouseState::Release) {
        // Remove modifiers
        modifiers_ &= ~(EVENTFLAG_LEFT_MOUSE_BUTTON | EVENTFLAG_MIDDLE_MOUSE_BUTTON |
                        EVENTFLAG_MIDDLE_MOUSE_BUTTON);
    } else {
        // Add modifiers
        modifiers_ |= (e->button() & MouseButton::Left ? EVENTFLAG_LEFT_MOUSE_BUTTON : 0) |
                      (e->button() & MouseButton::Middle ? EVENTFLAG_MIDDLE_MOUSE_BUTTON : 0) |
                      (e->button() & MouseButton::Right ? EVENTFLAG_RIGHT_MOUSE_BUTTON : 0);
    }
}
void CEFInteractionHandler::updateMouseStates(TouchEvent* e) {
    if (e->touchPoints().front().state() & TouchState::Finished) {
        // Remove modifiers
        modifiers_ &= ~(EVENTFLAG_LEFT_MOUSE_BUTTON | EVENTFLAG_MIDDLE_MOUSE_BUTTON |
                        EVENTFLAG_MIDDLE_MOUSE_BUTTON);
    } else {
        // Add modifiers
        modifiers_ |= (EVENTFLAG_LEFT_MOUSE_BUTTON);
    }
}
};  // namespace inviwo


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                xmlns:app="http://schemas.android.com/apk/res-auto"
                android:layout_width="match_parent"
                android:layout_height="match_parent">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <TextView
            android:id="@+id/textview_no_monster"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:gravity="center"
            android:padding="8dip"
            android:text="@string/tabMonster_msg_no_monsters"
            android:textColor="@color/apptheme_color"/>

        <android.support.v4.widget.SwipeRefreshLayout
            android:id="@+id/swipeRefreshLayout_monster_list"
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <android.support.v7.widget.RecyclerView
                android:id="@+id/recycler_monsters_list"
                android:layout_width="match_parent"
                android:layout_height="match_parent"/>

        </android.support.v4.widget.SwipeRefreshLayout>

    </LinearLayout>

    <com.rey.material.widget.ProgressView
        android:id="@+id/progressView"
        android:layout_width="48dip"
        android:layout_height="48dip"
        android:layout_centerInParent="true"
        app:pv_autostart="false"
        app:pv_circular="true"
        app:pv_progressMode="indeterminate"
        app:pv_progressStyle="@style/Material.Drawable.CircularProgress"/>

</RelativeLayout>


text:
require 'spec_helper'

require 'puppet/pops'
require 'puppet/pops/evaluator/evaluator_impl'

# relative to this spec file (./) does not work as this file is loaded by rspec
require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')

describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
  include EvaluatorRspecHelper

  context "When the evaluator performs comparisons" do

    context "of string values" do
      it "'a' == 'a' == true"  do; evaluate(literal('a') == literal('a')).should == true   ; end
      it "'a' == 'b' == false" do; evaluate(literal('a') == literal('b')).should == false  ; end
      it "'a' != 'a' == false" do; evaluate(literal('a').ne(literal('a'))).should == false ; end
      it "'a' != 'b' == true"  do; evaluate(literal('a').ne(literal('b'))).should == true  ; end

      it "'a' < 'b'  == true"  do; evaluate(literal('a')  < literal('b')).should == true   ; end
      it "'a' < 'a'  == false" do; evaluate(literal('a')  < literal('a')).should == false  ; end
      it "'b' < 'a'  == false" do; evaluate(literal('b')  < literal('a')).should == false  ; end

      it "'a' <= 'b' == true"  do; evaluate(literal('a')  <= literal('b')).should == true  ; end
      it "'a' <= 'a' == true"  do; evaluate(literal('a')  <= literal('a')).should == true  ; end
      it "'b' <= 'a' == false" do; evaluate(literal('b')  <= literal('a')).should == false ; end

      it "'a' > 'b'  == false" do; evaluate(literal('a')  > literal('b')).should == false  ; end
      it "'a' > 'a'  == false" do; evaluate(literal('a')  > literal('a')).should == false  ; end
      it "'b' > 'a'  == true"  do; evaluate(literal('b')  > literal('a')).should == true   ; end

      it "'a' >= 'b' == false" do; evaluate(literal('a')  >= literal('b')).should == false ; end
      it "'a' >= 'a' == true"  do; evaluate(literal('a')  >= literal('a')).should == true  ; end
      it "'b' >= 'a' == true"  do; evaluate(literal('b')  >= literal('a')).should == true  ; end

      context "with mixed case" do
        it "'a' == 'A' == true"    do; evaluate(literal('a') == literal('A')).should == true   ; end
        it "'a' != 'A' == false"   do; evaluate(literal('a').ne(literal('A'))).should == false ; end
        it "'a' >  'A' == false"   do; evaluate(literal('a') > literal('A')).should == false   ; end
        it "'a' >= 'A' == true"    do; evaluate(literal('a') >= literal('A')).should == true   ; end
        it "'A' <  'a' == false"   do; evaluate(literal('A') < literal('a')).should == false   ; end
        it "'A' <= 'a' == true"    do; evaluate(literal('A') <= literal('a')).should == true  ; end
      end
    end

    context "of integer values" do
      it "1 == 1 == true"  do; evaluate(literal(1) == literal(1)).should == true   ; end
      it "1 == 2 == false" do; evaluate(literal(1) == literal(2)).should == false  ; end
      it "1 != 1 == false" do; evaluate(literal(1).ne(literal(1))).should == false ; end
      it "1 != 2 == true"  do; evaluate(literal(1).ne(literal(2))).should == true  ; end

      it "1 < 2  == true"  do; evaluate(literal(1)  < literal(2)).should == true   ; end
      it "1 < 1  == false" do; evaluate(literal(1)  < literal(1)).should == false  ; end
      it "2 < 1  == false" do; evaluate(literal(2)  < literal(1)).should == false  ; end

      it "1 <= 2 == true"  do; evaluate(literal(1)  <= literal(2)).should == true  ; end
      it "1 <= 1 == true"  do; evaluate(literal(1)  <= literal(1)).should == true  ; end
      it "2 <= 1 == false" do; evaluate(literal(2)  <= literal(1)).should == false ; end

      it "1 > 2  == false" do; evaluate(literal(1)  > literal(2)).should == false  ; end
      it "1 > 1  == false" do; evaluate(literal(1)  > literal(1)).should == false  ; end
      it "2 > 1  == true"  do; evaluate(literal(2)  > literal(1)).should == true   ; end

      it "1 >= 2 == false" do; evaluate(literal(1)  >= literal(2)).should == false ; end
      it "1 >= 1 == true"  do; evaluate(literal(1)  >= literal(1)).should == true  ; end
      it "2 >= 1 == true"  do; evaluate(literal(2)  >= literal(1)).should == true  ; end
    end

    context "of mixed value types" do
      it "1 == 1.0  == true"   do; evaluate(literal(1)     == literal(1.0)).should == true   ; end
      it "1 < 1.1   == true"   do; evaluate(literal(1)     <  literal(1.1)).should == true   ; end
      it "'1' < 1.1 == true"   do; evaluate(literal('1')   <  literal(1.1)).should == true   ; end
      it "1.0 == 1  == true"   do; evaluate(literal(1.0)   == literal(1)).should == true     ; end
      it "1.0 < 2   == true"   do; evaluate(literal(1.0)   <  literal(2)).should == true     ; end
      it "'1.0' < 1.1 == true" do; evaluate(literal('1.0') <  literal(1.1)).should == true   ; end

      it "'1.0' < 'a' == true" do; evaluate(literal('1.0') <  literal('a')).should == true   ; end
      it "'1.0' < ''  == true" do; evaluate(literal('1.0') <  literal('')).should == true    ; end
      it "'1.0' < ' ' == true" do; evaluate(literal('1.0') <  literal(' ')).should == true   ; end
      it "'a' > '1.0' == true" do; evaluate(literal('a')   >  literal('1.0')).should == true ; end
    end

    context "of regular expressions" do
      it "/.*/ == /.*/  == true"   do; evaluate(literal(/.*/) == literal(/.*/)).should == true   ; end
      it "/.*/ != /a.*/ == true"   do; evaluate(literal(/.*/).ne(literal(/a.*/))).should == true ; end
    end

    context "of booleans" do
      it "true  == true  == true"  do; evaluate(literal(true) == literal(true)).should == true  ; end;
      it "false == false == true" do; evaluate(literal(false) == literal(false)).should == true ; end;
      it "true == false  != true" do; evaluate(literal(true) == literal(false)).should == false ; end;
      it "false  == ''  == false"  do; evaluate(literal(false) == literal('')).should == false  ; end;
    end

    context "of collections" do
      it "[1,2,3] == [1,2,3] == true" do
        evaluate(literal([1,2,3]) == literal([1,2,3])).should == true
        evaluate(literal([1,2,3]).ne(literal([1,2,3]))).should == false
        evaluate(literal([1,2,4]) == literal([1,2,3])).should == false
        evaluate(literal([1,2,4]).ne(literal([1,2,3]))).should == true
      end

      it "{'a'=>1, 'b'=>2} == {'a'=>1, 'b'=>2} == true" do
        evaluate(literal({'a'=>1, 'b'=>2}) == literal({'a'=>1, 'b'=>2})).should == true
        evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'a'=>1, 'b'=>2}))).should == false
        evaluate(literal({'a'=>1, 'b'=>2}) == literal({'x'=>1, 'b'=>2})).should == false
        evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'x'=>1, 'b'=>2}))).should == true
      end
    end

    context "of non comparable types" do
      # TODO: Change the exception type
      it "false < true  == error" do; expect { evaluate(literal(true) <  literal(false))}.to raise_error(Puppet::ParseError); end
      it "false <= true == error" do; expect { evaluate(literal(true) <= literal(false))}.to raise_error(Puppet::ParseError); end
      it "false > true  == error" do; expect { evaluate(literal(true) >  literal(false))}.to raise_error(Puppet::ParseError); end
      it "false >= true == error" do; expect { evaluate(literal(true) >= literal(false))}.to raise_error(Puppet::ParseError); end

      it "/a/ < /b/  == error" do; expect { evaluate(literal(/a/) <  literal(/b/))}.to raise_error(Puppet::ParseError); end
      it "/a/ <= /b/ == error" do; expect { evaluate(literal(/a/) <= literal(/b/))}.to raise_error(Puppet::ParseError); end
      it "/a/ > /b/  == error" do; expect { evaluate(literal(/a/) >  literal(/b/))}.to raise_error(Puppet::ParseError); end
      it "/a/ >= /b/ == error" do; expect { evaluate(literal(/a/) >= literal(/b/))}.to raise_error(Puppet::ParseError); end

      it "[1,2,3] < [1,2,3] == error" do
        expect{ evaluate(literal([1,2,3]) < literal([1,2,3]))}.to raise_error(Puppet::ParseError)
      end

      it "[1,2,3] > [1,2,3] == error" do
        expect{ evaluate(literal([1,2,3]) > literal([1,2,3]))}.to raise_error(Puppet::ParseError)
      end

      it "[1,2,3] >= [1,2,3] == error" do
        expect{ evaluate(literal([1,2,3]) >= literal([1,2,3]))}.to raise_error(Puppet::ParseError)
      end

      it "[1,2,3] <= [1,2,3] == error" do
        expect{ evaluate(literal([1,2,3]) <= literal([1,2,3]))}.to raise_error(Puppet::ParseError)
      end

      it "{'a'=>1, 'b'=>2} < {'a'=>1, 'b'=>2} == error" do
        expect{ evaluate(literal({'a'=>1, 'b'=>2}) < literal({'a'=>1, 'b'=>2}))}.to raise_error(Puppet::ParseError)
      end

      it "{'a'=>1, 'b'=>2} > {'a'=>1, 'b'=>2} == error" do
        expect{ evaluate(literal({'a'=>1, 'b'=>2}) > literal({'a'=>1, 'b'=>2}))}.to raise_error(Puppet::ParseError)
      end

      it "{'a'=>1, 'b'=>2} <= {'a'=>1, 'b'=>2} == error" do
        expect{ evaluate(literal({'a'=>1, 'b'=>2}) <= literal({'a'=>1, 'b'=>2}))}.to raise_error(Puppet::ParseError)
      end

      it "{'a'=>1, 'b'=>2} >= {'a'=>1, 'b'=>2} == error" do
        expect{ evaluate(literal({'a'=>1, 'b'=>2}) >= literal({'a'=>1, 'b'=>2}))}.to raise_error(Puppet::ParseError)
      end
    end
  end

  context "When the evaluator performs Regular Expression matching" do
    it "'a' =~ /.*/   == true"    do; evaluate(literal('a') =~ literal(/.*/)).should == true     ; end
    it "'a' =~ '.*'   == true"    do; evaluate(literal('a') =~ literal(".*")).should == true     ; end
    it "'a' !~ /b.*/  == true"    do; evaluate(literal('a').mne(literal(/b.*/))).should == true  ; end
    it "'a' !~ 'b.*'  == true"    do; evaluate(literal('a').mne(literal("b.*"))).should == true  ; end

    it "'a' =~ Pattern['.*'] == true"    do
      evaluate(literal('a') =~ fqr('Pattern')[literal(".*")]).should == true
    end

    it "$a = Pattern['.*']; 'a' =~ $a  == true"    do
      expr = block(var('a').set(fqr('Pattern')['foo']), literal('foo') =~ var('a'))
      evaluate(expr).should == true
    end

    it 'should fail if LHS is not a string' do
      expect { evaluate(literal(666) =~ literal(/6/))}.to raise_error(Puppet::ParseError)
    end
  end

  context "When evaluator evaluates the 'in' operator" do
    it "should find elements in an array" do
      evaluate(literal(1).in(literal([1,2,3]))).should == true
      evaluate(literal(4).in(literal([1,2,3]))).should == false
    end

    it "should find keys in a hash" do
      evaluate(literal('a').in(literal({'x'=>1, 'a'=>2, 'y'=> 3}))).should == true
      evaluate(literal('z').in(literal({'x'=>1, 'a'=>2, 'y'=> 3}))).should == false
    end

    it "should find substrings in a string" do
      evaluate(literal('ana').in(literal('bananas'))).should == true
      evaluate(literal('xxx').in(literal('bananas'))).should == false
    end

    it "should find substrings in a string (regexp)" do
      evaluate(literal(/ana/).in(literal('bananas'))).should == true
      evaluate(literal(/xxx/).in(literal('bananas'))).should == false
    end

    it "should find substrings in a string (ignoring case)" do
      evaluate(literal('ANA').in(literal('bananas'))).should == true
      evaluate(literal('ana').in(literal('BANANAS'))).should == true
      evaluate(literal('xxx').in(literal('BANANAS'))).should == false
    end

    it "should find sublists in a list" do
      evaluate(literal([2,3]).in(literal([1,[2,3],4]))).should == true
      evaluate(literal([2,4]).in(literal([1,[2,3],4]))).should == false
    end

    it "should find sublists in a list (case insensitive)" do
      evaluate(literal(['a','b']).in(literal(['A',['A','B'],'C']))).should == true
      evaluate(literal(['x','y']).in(literal(['A',['A','B'],'C']))).should == false
    end

    it "should find keys in a hash" do
      evaluate(literal('a').in(literal({'a' => 10, 'b' => 20}))).should == true
      evaluate(literal('x').in(literal({'a' => 10, 'b' => 20}))).should == false
    end

    it "should find keys in a hash (case insensitive)" do
      evaluate(literal('A').in(literal({'a' => 10, 'b' => 20}))).should == true
      evaluate(literal('X').in(literal({'a' => 10, 'b' => 20}))).should == false
    end

    it "should find keys in a hash (regexp)" do
      evaluate(literal(/xxx/).in(literal({'abcxxxabc' => 10, 'xyz' => 20}))).should == true
      evaluate(literal(/yyy/).in(literal({'abcxxxabc' => 10, 'xyz' => 20}))).should == false
    end

    it "should find numbers as numbers" do
      evaluate(literal(15).in(literal([1,0xf,2]))).should == true
    end

    it "should find numbers as strings" do
      evaluate(literal(15).in(literal([1, '0xf',2]))).should == true
      evaluate(literal('15').in(literal([1, 0xf,2]))).should == true
    end

    it "should not find numbers embedded in strings, nor digits in numbers" do
      evaluate(literal(15).in(literal([1, '115', 2]))).should == false
      evaluate(literal(1).in(literal([11, 111, 2]))).should == false
      evaluate(literal('1').in(literal([11, 111, 2]))).should == false
    end

    it 'should find an entry with compatible type in an Array' do
      evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,3], 'b']))).should == true
      evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,'not integer'], 'b']))).should == false
    end

    it 'should find an entry with compatible type in a Hash' do
      evaluate(fqr('Integer').in(literal({1 => 'a', 'a' => 'b'}))).should == true
      evaluate(fqr('Integer').in(literal({'a' => 'a', 'a' => 'b'}))).should == false
    end
  end
end


text:
from __future__ import unicode_literals
import os
import os.path

PROJ_ROOT = os.path.abspath(os.path.dirname(__file__))
DATA_ROOT = os.path.join(PROJ_ROOT, 'data')

DEBUG = True

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': 'db'
    }
}

INSTALLED_APPS = (
    'django.contrib.contenttypes',

    'sorl.thumbnail',
    'thumbnail_maker',

    'testapp',
)

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'APP_DIRS': True,
    },
]

TEMPLATE_CONTEXT_PROCESSORS = (
    "django.core.context_processors.request",
)

SITE_ID = 1

MEDIA_ROOT = os.path.join(PROJ_ROOT, 'media')
MEDIA_URL = '/media/'

#ROOT_URLCONF = 'testapp.urls'

# Required for Django 1.4+
STATIC_URL = '/static/'

# Required for Django 1.5+
SECRET_KEY = 'abc123'

# Required for Django 1.7
MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

THUMBNAIL_MAKER_FORMATS = {
    'big':    ('500x400', {'crop': 'center', 'quality': 100}),
    'medium': ('200x150', {'crop': 'center'}),
    'small':  ('80x80',   {'crop': 'center'}),
}

#TEST_RUNNER = 'django_coverage.coverage_runner.CoverageRunner'


text:
class Capybara::AsyncRunner::Env
  # @param uuid [String] just a uuid of running command
  # @param data [Hash] data that is available in .erb through <%= data[:something] %>
  # @param responders [Hash<Symbol, Hash>] mapping method_name => options
  #
  # For responders:
  # @see Capybara::AsyncRunner::Commands::Responders
  #
  def initialize(uuid, data, responders)
    @uuid = uuid
    @data = data
    @responders = responders
  end
  attr_reader :data, :responders, :uuid

  # Returns a js environment that can be used for fetching data from the code on-the-fly
  #
  # @example
  #   # spec/support/async_runner/templates/command1.js.erb
  #   var jsLocal = 123;
  #   <%= done(js[:jsLocal] %>
  #
  def js_environment
    Hash.new do |h, k|
      k.to_s
    end
  end
  alias_method :js, :js_environment

  # Delegates a method to responder
  #
  # @example
  #   <%= responder1(js[:var1]) %>
  #
  # @see Capybara::AsyncRunner::Commands::Responders
  #
  def method_missing(method_name, *args)
    if responders.include?(method_name)
      response_method_for(method_name, *args)
    else
      super
    end
  end

  # @private
  def respond_to_missing?(method_name, include_private = false)
    super || responders.include?(method_name)
  end

  # Returns local binding that is used for rendering (ERB.new(template).result(binding))
  #
  # @return [Binding]
  #
  def local_binding
    binding
  end

  attr_reader :responders

  private

  def response_method_for(method_name, *args)
    options = responders[method_name][:options]
    if options[:as] == :callback
      <<-JS
      function() {
        var args = Array.prototype.slice.call(arguments, 0);
        window.Capybara[#{uuid.inspect}] = { from: #{method_name.to_s.inspect}, data: args };
      }
      JS
    else
      formatted_args = "[#{args.join(', ')}]"
      "window.Capybara[#{uuid.inspect}] = { from: #{method_name.to_s.inspect}, data: #{formatted_args} };"
    end
  end
end


text:
import sys
import json
import asyncio
from time import sleep
import random
from multiprocessing import Process
import websockets

class GameClient:
    def __init__(self):
        self.handle = ''
        self.pair_handle = ''
        self.open_positions = ''
        self.my_move = False

    def handle_message(self, data):
        send_data = None
        # print('Messages: ', data)
        if data['action'] == 'connect':
            self.handle = data['handle']
            send_data = {}
            send_data['action'] = 'ready'
            send_data['handle'] = self.handle
            print('Client Connection: ', self.handle)
        elif data['action'] == 'paired':
            self.pair_handle = data['pair']
        elif data['action'] == 'game-start':
            print('Game Started: ', self.handle, 'Vs. ', self.pair_handle)
            if data['next_handle'] == self.handle:
                self.my_move = True
            else:
                self.my_move = False
            self.open_positions = data['valid-moves']
        elif data['action'] == 'valid-moves':
            if data['next_handle'] == self.handle:
                self.open_positions = data['valid-moves']
                self.my_move = True
        elif data['action'] == 'player-move':
            pass
        elif data['action'] == 'game-end':
            print('Game End: ', self.handle, 'Vs. ', self.pair_handle, 'Result: ', data['result'], ' : ', data['win_handle'])
            # Game Over
            self.my_move = False
            send_data = {}
            send_data['action'] = 'ready'
            send_data['handle'] = self.handle
        if self.my_move:
            # select a piece to move
            self.my_move = False
            send_data = {}
            send_data['action'] = 'player-move'
            send_data['handle'] = self.handle
            send_data['move'] = random.choice(self.open_positions.split(';'))
        return send_data

@asyncio.coroutine
def main_websocket(ws_url):
    websocket = yield from websockets.connect(ws_url)
    game_client = GameClient()
    while True:
        message = yield from websocket.recv()
        if message is not None:
            data = json.loads(message)
            send_data = game_client.handle_message(data)
            if send_data:
                sleep(1)  # wait for 1 seconds before sending messages
                yield from websocket.send(json.dumps(send_data))

def main(worker_numb, ws_url):
    asyncio.get_event_loop().run_until_complete(main_websocket(ws_url))

if __name__ == '__main__':
    if len(sys.argv) > 1 and sys.argv[1] == 'local':
        ws_url = 'ws://localhost:8001/tic-tac-toe/'
    else:
        ws_url = "ws://websockets-test-ha-1776378039.us-west-1.elb.amazonaws.com/tic-tac-toe/"

    # Setup a list of processes that we want to run
    processes = [Process(target=main, args=(x, ws_url)) for x in range(20)]

    # Run processes
    for p in processes:
        sleep(0.5)
        p.start()

    # Exit the completed processes
    for p in processes:
        p.join()


text:
"""Tests for xmlreader module."""
#
# (C) Pywikibot team, 2009-2014
#
# Distributed under the terms of the MIT license.
#
from __future__ import absolute_import, unicode_literals

from pywikibot import xmlreader

from tests import join_xml_data_path
from tests.aspects import unittest, TestCase

class XmlReaderTestCase(TestCase):

    """XML Reader test cases."""

    net = False

    def _get_entries(self, filename, **kwargs):
        """Get all entries via XmlDump."""
        entries = [r for r in
                   xmlreader.XmlDump(join_xml_data_path(filename),
                                     **kwargs).parse()]
        return entries

class ExportDotThreeTestCase(XmlReaderTestCase):

    """XML export version 0.3 tests."""

    def test_XmlDumpAllRevs(self):
        """Test loading all revisions."""
        pages = self._get_entries('article-pear.xml', allrevisions=True)
        self.assertEqual(4, len(pages))
        self.assertEqual(u"Automated conversion", pages[0].comment)
        self.assertEqual(u"Pear", pages[0].title)
        self.assertEqual(u"24278", pages[0].id)
        self.assertTrue(pages[0].text.startswith('Pears are [[tree]]s of'))
        self.assertEqual(u"Quercusrobur", pages[1].username)
        self.assertEqual(u"Pear", pages[0].title)

    def test_XmlDumpFirstRev(self):
        """Test loading the first revision."""
        pages = self._get_entries("article-pear.xml", allrevisions=False)
        self.assertEqual(1, len(pages))
        self.assertEqual(u"Automated conversion", pages[0].comment)
        self.assertEqual(u"Pear", pages[0].title)
        self.assertEqual(u"24278", pages[0].id)
        self.assertTrue(pages[0].text.startswith('Pears are [[tree]]s of'))
        self.assertTrue(not pages[0].isredirect)

    def test_XmlDumpRedirect(self):
        """Test XmlDump correctly parsing whether a page is a redirect."""
        pages = self._get_entries('article-pyrus.xml', allrevisions=True)
        pages = [r for r in
                 xmlreader.XmlDump(join_xml_data_path('article-pyrus.xml')).parse()]
        self.assertTrue(pages[0].isredirect)

    def _compare(self, previous, variant, all_revisions):
        """Compare the tested variant with the previous (if not None)."""
        entries = self._get_entries('article-pyrus' + variant,
                                    allrevisions=all_revisions)
        result = [entry.__dict__ for entry in entries]
        if previous:
            self.assertEqual(previous, result)
        return result

    def _compare_variants(self, all_revisions):
        """Compare the different XML file variants."""
        previous = None
        previous = self._compare(previous, '.xml', all_revisions)
        previous = self._compare(previous, '-utf16.xml', all_revisions)
        previous = self._compare(previous, '.xml.bz2', all_revisions)
        previous = self._compare(previous, '-utf16.xml.bz2', all_revisions)

    def test_XmlDump_compare_all(self):
        """Compare the different XML files using all revisions."""
        self._compare_variants(True)

    def test_XmlDump_compare_single(self):
        """Compare the different XML files using only a single revision."""
        self._compare_variants(False)

class ExportDotTenTestCase(XmlReaderTestCase):

    """XML export version 0.10 tests."""

    def test_pair(self):
        """Test reading the main page/user talk page pair file."""
        entries = self._get_entries('pair-0.10.xml', allrevisions=True)
        self.assertEqual(4, len(entries))
        self.assertTrue(all(entry.username == 'Carlossuarez46'
                            for entry in entries))
        self.assertTrue(all(entry.isredirect is False for entry in entries))

        articles = entries[0:2]
        talks = entries[2:4]

        self.assertEqual(2, len(articles))
        self.assertTrue(all(entry.id == "19252820" for entry in articles))
        self.assertTrue(all(entry.title == u"Çullu, Agdam"
                            for entry in articles))
        self.assertTrue(all(u'Çullu, Quzanlı' in entry.text
                            for entry in articles))
        self.assertEqual(articles[0].text, u'#REDIRECT [[Çullu, Quzanlı]]')

        self.assertEqual(2, len(talks))
        self.assertTrue(all(entry.id == "19252824" for entry in talks))
        self.assertTrue(all(entry.title == u"Talk:Çullu, Agdam"
                            for entry in talks))
        self.assertEqual(talks[1].text, '{{DisambigProject}}')
        self.assertEqual(talks[1].comment, 'proj')

    def test_edit_summary_decoding(self):
        """Test edit summaries are decoded."""
        entries = self._get_entries('pair-0.10.xml', allrevisions=True)
        articles = [entry for entry in entries if entry.ns == "0"]

        # It does not decode the edit summary
        self.assertEqual(articles[0].comment,
                         u'moved [[Çullu, Agdam]] to [[Çullu, Quzanlı]]: dab')

if __name__ == '__main__':  # pragma: no cover
    try:
        unittest.main()
    except SystemExit:
        pass


text:
package testJDK8;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class TestThread {
   /*
	*Ïß³ÌËÀÑ»·ÑÝʾ
	*/
	public static void createBusyThread(){
		new Thread(new Runnable(){
	@Override
	public void run(){
	while(true){

	}
	}
	},"testLockThread1").start();
	}
	/*
	**
	*Ïß³ÌËøµÈ´ýÑÝʾ
	*/
	public static void createLockThread(final Object lock){
	Thread thread=new Thread(new Runnable(){
	@Override
	public void run(){
	synchronized(lock){
	try{
	lock.wait();
	}catch(InterruptedException e){
	e.printStackTrace();
	}}}}
	,"testLockThread2");
	thread.start();
	}
	public static void main(String[] args)throws Exception{
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	br.readLine();
	createBusyThread();
	br.readLine();
	Object obj=new Object();
	createLockThread(obj);
	}

}


text:
#ifndef POSIX_TIME_SERIALIZE_HPP___
#define POSIX_TIME_SERIALIZE_HPP___

#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/date_time/gregorian/greg_serialize.hpp"
#include "boost/numeric/conversion/cast.hpp"
#include "boost/serialization/split_free.hpp"
#include "boost/serialization/nvp.hpp"
#include "boost/serialization/version.hpp"

// macros to split serialize functions into save & load functions
// NOTE: these macros define template functions in the boost::serialization namespace.
// They must be expanded *outside* of any namespace
BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::ptime)
BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_duration)
BOOST_SERIALIZATION_SPLIT_FREE(boost::posix_time::time_period)

// Define versions for serialization compatibility
// alows the unit tests to make an older version to check compatibility
#ifndef BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION
#define BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION 1
#endif

BOOST_CLASS_VERSION(boost::posix_time::time_duration, BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION)

namespace boost {
namespace serialization {

/*** time_duration ***/

//! Function to save posix_time::time_duration objects using serialization lib
/*! time_duration objects are broken down into 4 parts for serialization:
 * types are hour_type, min_type, sec_type, and fractional_seconds_type
 * as defined in the time_duration class
 */
template<class TimeResTraitsSize, class Archive>
void save_td(Archive& ar, const posix_time::time_duration& td)
{
    TimeResTraitsSize h = boost::numeric_cast<TimeResTraitsSize>(td.hours());
    TimeResTraitsSize m = boost::numeric_cast<TimeResTraitsSize>(td.minutes());
    TimeResTraitsSize s = boost::numeric_cast<TimeResTraitsSize>(td.seconds());
    posix_time::time_duration::fractional_seconds_type fs = td.fractional_seconds();
    ar & make_nvp("time_duration_hours", h);
    ar & make_nvp("time_duration_minutes", m);
    ar & make_nvp("time_duration_seconds", s);
    ar & make_nvp("time_duration_fractional_seconds", fs);
}

template<class Archive>
void save(Archive & ar,
          const posix_time::time_duration& td,
          unsigned int version)
{
  // serialize a bool so we know how to read this back in later
  bool is_special = td.is_special();
  ar & make_nvp("is_special", is_special);
  if(is_special) {
    std::string s = to_simple_string(td);
    ar & make_nvp("sv_time_duration", s);
  }
  else {
    // Write support for earlier versions allows for upgrade compatibility testing
    // See load comments for version information
    if (version == 0) {
        save_td<int32_t>(ar, td);
    } else {
        save_td<int64_t>(ar, td);
    }
  }
}

//! Function to load posix_time::time_duration objects using serialization lib
/*! time_duration objects are broken down into 4 parts for serialization:
 * types are hour_type, min_type, sec_type, and fractional_seconds_type
 * as defined in the time_duration class
 */
template<class TimeResTraitsSize, class Archive>
void load_td(Archive& ar, posix_time::time_duration& td)
{
    TimeResTraitsSize h(0);
    TimeResTraitsSize m(0);
    TimeResTraitsSize s(0);
    posix_time::time_duration::fractional_seconds_type fs(0);
    ar & make_nvp("time_duration_hours", h);
    ar & make_nvp("time_duration_minutes", m);
    ar & make_nvp("time_duration_seconds", s);
    ar & make_nvp("time_duration_fractional_seconds", fs);
    td = posix_time::time_duration(h, m, s, fs);
}

template<class Archive>
void load(Archive & ar,
          posix_time::time_duration & td,
          unsigned int version)
{
  bool is_special = false;
  ar & make_nvp("is_special", is_special);
  if(is_special) {
    std::string s;
    ar & make_nvp("sv_time_duration", s);
    posix_time::special_values sv = gregorian::special_value_from_string(s);
    td = posix_time::time_duration(sv);
  }
  else {
    // Version "0"   (Boost 1.65.1 or earlier, which used int32_t for day/hour/minute/second and
    //                therefore suffered from the year 2038 issue.)
    // Version "0.5" (Boost 1.66.0 changed to std::time_t but did not increase the version;
    //                it was missed in the original change, all code reviews, and there were no
    //                static assertions to protect the code; further std::time_t can be 32-bit
    //                or 64-bit so it reduced portability.  This makes 1.66.0 hard to handle...)
    // Version "1"   (Boost 1.67.0 or later uses int64_t and is properly versioned)

    // If the size of any of these items changes, a new version is needed.
    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::hour_type) == sizeof(boost::int64_t));
    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::min_type) == sizeof(boost::int64_t));
    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::sec_type) == sizeof(boost::int64_t));
    BOOST_STATIC_ASSERT(sizeof(posix_time::time_duration::fractional_seconds_type) == sizeof(boost::int64_t));

    if (version == 0) {
        load_td<int32_t>(ar, td);
    } else {
        load_td<int64_t>(ar, td);
    }
  }
}

// no load_construct_data function provided as time_duration provides a
// default constructor

/*** ptime ***/

//! Function to save posix_time::ptime objects using serialization lib
/*! ptime objects are broken down into 2 parts for serialization:
 * a date object and a time_duration onject
 */
template<class Archive>
void save(Archive & ar,
          const posix_time::ptime& pt,
          unsigned int /*version*/)
{
  // from_iso_string does not include fractional seconds
  // therefore date and time_duration are used
  posix_time::ptime::date_type d = pt.date();
  ar & make_nvp("ptime_date", d);
  if(!pt.is_special()) {
    posix_time::ptime::time_duration_type td = pt.time_of_day();
    ar & make_nvp("ptime_time_duration", td);
  }
}

//! Function to load posix_time::ptime objects using serialization lib
/*! ptime objects are broken down into 2 parts for serialization:
 * a date object and a time_duration onject
 */
template<class Archive>
void load(Archive & ar,
          posix_time::ptime & pt,
          unsigned int /*version*/)
{
  // from_iso_string does not include fractional seconds
  // therefore date and time_duration are used
  posix_time::ptime::date_type d(posix_time::not_a_date_time);
  posix_time::ptime::time_duration_type td;
  ar & make_nvp("ptime_date", d);
  if(!d.is_special()) {
    ar & make_nvp("ptime_time_duration", td);
    pt = boost::posix_time::ptime(d,td);
  }
  else {
    pt = boost::posix_time::ptime(d.as_special());
  }

}

//!override needed b/c no default constructor
template<class Archive>
inline void load_construct_data(Archive & /*ar*/,
                                posix_time::ptime* pt,
                                const unsigned int /*file_version*/)
{
  // retrieve data from archive required to construct new
  // invoke inplace constructor to initialize instance of date
  new(pt) boost::posix_time::ptime(boost::posix_time::not_a_date_time);
}

/*** time_period ***/

//! Function to save posix_time::time_period objects using serialization lib
/*! time_period objects are broken down into 2 parts for serialization:
 * a begining ptime object and an ending ptime object
 */
template<class Archive>
void save(Archive & ar,
          const posix_time::time_period& tp,
          unsigned int /*version*/)
{
  posix_time::ptime beg(tp.begin().date(), tp.begin().time_of_day());
  posix_time::ptime end(tp.end().date(), tp.end().time_of_day());
  ar & make_nvp("time_period_begin", beg);
  ar & make_nvp("time_period_end", end);
}

//! Function to load posix_time::time_period objects using serialization lib
/*! time_period objects are broken down into 2 parts for serialization:
 * a begining ptime object and an ending ptime object
 */
template<class Archive>
void load(Archive & ar,
          boost::posix_time::time_period & tp,
          unsigned int /*version*/)
{
  posix_time::time_duration td(1,0,0);
  gregorian::date d(gregorian::not_a_date_time);
  posix_time::ptime beg(d,td);
  posix_time::ptime end(d,td);
  ar & make_nvp("time_period_begin", beg);
  ar & make_nvp("time_period_end", end);
  tp = boost::posix_time::time_period(beg, end);
}

//!override needed b/c no default constructor
template<class Archive>
inline void load_construct_data(Archive & /*ar*/,
                                boost::posix_time::time_period* tp,
                                const unsigned int /*file_version*/)
{
  posix_time::time_duration td(1,0,0);
  gregorian::date d(gregorian::not_a_date_time);
  posix_time::ptime beg(d,td);
  posix_time::ptime end(d,td);
  new(tp) boost::posix_time::time_period(beg,end);
}

} // namespace serialization
} // namespace boost

#endif


text:
import os
import shutil
import getpass
import sys
import fnmatch
from .Dependencer import Dependencer
from .BLSItem import BLSItem
from .BSSCompiler import BSSCompiler
from .StarTeam import StarTeam
from . import Helper

class BSSBuilder:
	BLS_LIST_FILE_NAME = 'blsList.txt'
	DLL_LIST_FILE_NAME = 'dllList.txt'

	PATCH_BANK_FOLDER   = 'Bank'
	PATCH_CLIENT_FOLDER = 'Client'
	PATCH_TEMP          = 'Temp'
	PATCH_OUT_COMMON    =   'Common'
	PATCH_OUT_BLS       =     'BLS'
	PATCH_OUT_USER      =     'USER'
	TEMPLATES_PATH = '.\\templates'

	def __init__(self, fastMode, compilerSettings = None, starteamSettigs = None):
		self.fastMode = fastMode
		self.error = []
		self.cycles = []
		self.blsCompiled = 0
		self.compilerSettings = compilerSettings
		self.starteamSettigs = starteamSettigs

		self.patchRootPath = ''
		self.patchBankPath = ''
		self.patchClientPath = ''
		self.patchTempPath = ''
		self.patchOutCommon = ''
		self.patchOutBls = ''

	def __initPatchPaths(self, patchFolder, patchVersion):
		self.patchRootPath = os.path.join(patchFolder, patchVersion)
		if not os.path.exists(self.patchRootPath):
			os.makedirs(self.patchRootPath)
		self.patchBankPath = os.path.join(self.patchRootPath, BSSBuilder.PATCH_BANK_FOLDER)
		self.patchClientPath = os.path.join(self.patchRootPath, BSSBuilder.PATCH_CLIENT_FOLDER)
		self.patchTempPath = os.path.join(self.patchRootPath, BSSBuilder.PATCH_TEMP)
		self.patchOutCommon = os.path.join(self.patchTempPath, BSSBuilder.PATCH_OUT_COMMON)
		self.patchOutBls = os.path.join(self.patchOutCommon, BSSBuilder.PATCH_OUT_BLS)
		self.patchOutUser = os.path.join(self.patchOutCommon, BSSBuilder.PATCH_OUT_USER)

	def __createTargetPath(self, targetPath, clear = True):
		if not targetPath:
			targetPath = self.workingDir + '\\user'
		if os.path.exists(targetPath):
			if clear:
				shutil.rmtree(targetPath)
				os.makedirs(targetPath)
		else:
			os.makedirs(targetPath)

	def getSortedBlsPathList(self, srcPath):
		dependencer = Dependencer(srcPath);

		blsItemsMap = {}
		dublicates = []

		if dependencer.blsDublicates:
			self.error.append('Have dublicates: ' + str(dependencer.blsDublicates) + '.')
			return None

		if len(dependencer.missingFiles):
			self.error.append('Files: ' + str(dependencer.missingFiles) + ' not founded in folder ' + srcPath + ', but this files uses in modules.')
			return None;

		self.cycles = dependencer.getCycles()
		if self.cycles:
			self.error.append('Sources have cycles.')
			return None

		sortedBlsList = dependencer.getOrder();

		if sortedBlsList:
			return sortedBlsList
		else:
			self.error.append('Not sorted BLSList.')
			return None

	def getDllList(self, systemPath):
		if not systemPath:
			return None
		dllList = []
		for root, dirs, files in os.walk(systemPath):
			for name in files:
				if name.upper().endswith('.DLL'):
					dllList.append(os.path.join(root, name))
		return dllList

	def compileAllBls(self, srcPath, destPath):
		if not self.compilerSettings:
			self.error.append('No compilerSettings.')
		if len(self.error):
			return None
		blsList = []
		if not srcPath:
			srcPath = self.compilerSettings.get('srcPath', '')
		sortedBlsPathList = self.getSortedBlsPathList(srcPath);
		if not sortedBlsPathList:
			self.error.append('Not created BLS list.')
			return None
		compiler = BSSCompiler(self.compilerSettings)
		self.__createTargetPath(destPath)
		if self.fastMode:
			if not Helper.listToFile(sortedBlsPathList, compiler.workingDir + '\\' + BSSBuilder.BLS_LIST_FILE_NAME):
				self.error.append('Not created BLS list file.')
				return None
			dllList = self.getDllList(compiler.workingDir + '\\' + 'SYSTEM')
			if not Helper.listToFile(dllList, compiler.workingDir + '\\' + BSSBuilder.DLL_LIST_FILE_NAME):
				self.error.append('Not created DLL list file.')
				return None
			compiler.compileBlsListFileName(compiler.workingDir + '\\' + BSSBuilder.BLS_LIST_FILE_NAME, compiler.workingDir + '\\' + BSSBuilder.DLL_LIST_FILE_NAME, destPath)
		else:
			sortedBlsPathList.reverse()
			compiler.userPaths = [destPath]
			def __onCompiled(copiedBlls):
				self.blsCompiled += 1
				if len(sortedBlsPathList) > 0:
					compiler.compile(sortedBlsPathList.pop())
				else:
					print('Compiled ' + str(self.blsCompiled) + ' bls.')
			def __onNoCompiled(compiler):
				print(blsPath + ' not compiled!')
			while sortedBlsPathList:
				blsPath = sortedBlsPathList.pop()
				bllFullPath = Helper.getBllPathByBlsPath(blsPath, compiler.version, compiler.workingDir)
				compiler.em.connect(BSSCompiler.EVENT_BLL_COPIED, __onCompiled, compiler)
				compiler.em.connect(BSSCompiler.EVENT_NOT_COMPILED, __onNoCompiled, compiler)
				compiler.compile(blsPath)

	def getStPsw(self):
		if not self.starteamSettigs.get('stPassword', ''):
			if sys.stdin.isatty():
				psw = getpass.getpass('StarTeam password: ')
			else:
				print('StarTeam password:')
				psw = sys.stdin.readline().rstrip()
			self.starteamSettigs.update({'stPassword': psw})

	def build(self):
		print('Develope it!!!')

	def __getBcFileList(self, blsList):
		result = []
		baseDir = os.path.join(self.patchOutCommon, 'BASE', 'CLIENT')
		if os.path.exists(baseDir):
			eifFiles = []
			eifFiles.extend(Helper.getFileLis(baseDir, '*.eif'))
			result.extend(eifFiles)
		if blsList:
			for fullFilePath in blsList:
				if fnmatch.fnmatch(fullFilePath, '*\\?c*.bls'):
					result.append(fullFilePath)
					filePath, fileName = os.path.split(fullFilePath)
					fileName, fileExtension = os.path.splitext(fileName)
					result.append(os.path.join(self.patchOutUser, fileName) + '.bll')
					continue
				if fnmatch.fnmatch(fullFilePath, '*\\?a*.bls'):
					result.append(fullFilePath)
					filePath, fileName = os.path.split(fullFilePath)
					fileName, fileExtension = os.path.splitext(fileName)
					result.append(os.path.join(self.patchOutUser, fileName) + '.bll')
					continue
		return result

	def __getIcFileLilst(self):
		result = []

	def __copyToPatchFolder(self, fileList, patchFolder):
		dataFolderPath = os.path.join(patchFolder, 'DATA')
		if not os.path.exists(dataFolderPath):
			os.makedirs(dataFolderPath)
		userFolderPath = os.path.join(patchFolder, 'LIBFILES', 'USER')
		if not os.path.exists(userFolderPath):
			os.makedirs(userFolderPath)
		for fullFilePath in fileList:
			fileName, fileExtension = os.path.splitext(fullFilePath)
			fileExtension = fileExtension.lower()
			if fileExtension == '.eif':
				shutil.copy2(fullFilePath, dataFolderPath)
			elif fileExtension == '.bll':
				print(fullFilePath)
				shutil.copy2(fullFilePath, userFolderPath)

	def createPatch(self, patchFolder, patchVersion, labels):
		self.__initPatchPaths(patchFolder, patchVersion)

		self.getStPsw()
		st = StarTeam(self.starteamSettigs)
		# checkoutDirs = []
		# for label in labels:
		# 	checkoutPath = os.path.join(self.patchTempPath, label)
		# 	st.checkOutByLabel(label, checkoutPath)
		# 	checkoutDirs.append(checkoutPath)

		checkoutDirs = ['D:\\MyPatch\\200123_RSHB_017_9_580\\Temp\\BIQ1', 'D:\\MyPatch\\200123_RSHB_017_9_580\\Temp\\BIQ2'] #temp
		Helper.mergeDirs(checkoutDirs, self.patchOutCommon)
		if os.path.exists(self.patchOutBls):
			blsList = []
			for root, dirs, files in os.walk(self.patchOutBls):
				for name in files:
					if name.upper().endswith('.BLS'):
						blsList.append(os.path.join(root, name))
			shutil.rmtree(self.patchOutBls)
			st.checkOutByFileFilter('BLS/SOURCE', '*.bls', self.patchOutBls)
			self.compileAllBls(self.patchOutBls, self.patchOutUser)

		bcFileList = self.__getBcFileList(blsList)
		if len(bcFileList) > 0:
			self.__copyToPatchFolder(bcFileList, self.patchClientPath)
			Helper.fullCopy(os.path.join(BSSBuilder.TEMPLATES_PATH, self.compilerSettings.get('version', '')), self.patchClientPath)


text:
<!--
    @license
    Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->
<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="../polymer-ajax/polymer-ajax.html">

<polymer-element name="x-file-document" attributes="text fileName root">
  <template>
    <polymer-ajax id="post" method="POST" on-polymer-complete="{{postComplete}}"></polymer-ajax>
    <polymer-ajax id="get" handleAs="text" response="{{text}}" on-polymer-complete="{{getComplete}}"></polymer-ajax>
  </template>
  <script>
    Polymer('x-file-document', {
      root: '',
      fileName: '',
      text: null,
      fileNameChanged: function() {
        //console.log(this.fileName);
        this.fetch();
      },
      get url() {
        return this.root + this.fileName;
      },
      fetch: function() {
        this.$.get.url = this.url;
        this.$.get.go();
      },
      getComplete: function(event) {
        event.stopPropagation();
        this.fire('file-document-loaded');
      },
      save: function() {
        this.$.post.xhrArgs = {
          headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
          }
        };
        this.$.post.url = this.url;
        this.$.post.params = {
          html: this.text
        };
        this.$.post.go();
      },
      postComplete: function(event) {
        event.stopPropagation();
        this.fire('file-document-saved');
      }
    });
  </script>
</polymer-element>


text:
package io.getlime.security.powerauth.lib.nextstep.model.request;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

/**
 * Request object used for getting a list of user credentials.
 *
 * @author Roman Strobl, roman.strobl@wultra.com
 */
@Data
public class GetUserCredentialListRequest {

    @NotBlank
    @Size(min = 1, max = 256)
    private String userId;
    private boolean includeRemoved;

}


text:
//
//  HomeViewController.m
//  TopSecretProjectForTeam11
//
//  Created by Mary Nguyen on 11/16/13.
//  Copyright (c) 2013 App Jam. All rights reserved.
//

#import "HomeViewController.h"

@interface HomeViewController ()

@end

@implementation HomeViewController

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
    self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
    if (self) {
        // Custom initialization
    }
    return self;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view.

    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setDateFormat:@"MM/dd/yy"];
    self.theDate = [formatter stringFromDate:[NSDate date]];
    self.dateDisplay.text = self.theDate;

    self.recentSymptoms = [[UIView alloc] init];

    /*self.currentSymptoms = [[UITableView alloc] init];
    self.currentSymptoms.delegate = self;
    self.currentSymptoms.dataSource = self;
    [self.currentSymptoms setAllowsSelection:YES];
    [self.view addSubview:self.currentSymptoms];
    [self.currentSymptoms reloadData];

    self.symptomsArray = [[NSMutableArray alloc] initWithObjects:@"sample symptom 1", @"recent symptom blah", nil];*/
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

/*-(NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return self.symptomsArray.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if(cell == nil)
    {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
    }
    cell.textLabel.text = self.symptomsArray[indexPath.row];
    return cell;
}*/

@end


text:
<?php
/**
 * Message translations.
 *
 * This file is automatically generated by 'yiic message' command.
 * It contains the localizable messages extracted from source code.
 * You may modify this file by translating the extracted messages.
 *
 * Each array element represents the translation (value) of a message (key).
 * If the value is empty, the message is considered as not translated.
 * Messages that no longer need translation will have their translations
 * enclosed between a pair of '@@' marks.
 *
 * Message string can be used with plural forms format. Check i18n section
 * of the guide for details.
 *
 * NOTE, this file must be saved in UTF-8 encoding.
 */
return array (
  'Nobody wrote something yet.
Make the beginning and post something...' => 'Ingen har skrevet noget endu.
Lav begyndelsen, og lav et indlæg...',
  'This profile stream is still empty' => 'Denne profils tidslinje er stadig tom',
  'This space is still empty!
Start by posting something here...' => 'Denne gruppe er stadig tom!
Start med at lave et indlæg...',
  'Your dashboard is empty!
Post something on your profile or join some groups!' => 'Din forside er tom!
Lav et indlæg på din profil, eller tildmæld dig til nogle grupper!',
  'Your profile stream is still empty
Get started and post something...' => 'Din profils tidslinje er stadig tom
Start ud med at lave et indlæg...',
  'Back to stream' => 'Tilbage til forside',
  'Content with attached files' => 'Indhold med vedhæftet filer',
  'Created by me' => 'Lavet af mig',
  'Creation time' => 'Tid at indlæget blev lavet',
  'Filter' => 'Filtré',
  'Include archived posts' => 'Inkludér arkiveret indlæg',
  'Last update' => 'Sidste opdatering',
  'Nothing found which matches your current filter(s)!' => 'Intet var fundet, der matchede dine filter/filtre',
  'Only private posts' => 'Kun private indlæg',
  'Only public posts' => 'Kun offentlige indlæg',
  'Posts only' => 'Kun indlæg',
  'Posts with links' => 'Indlæg med links',
  'Show all' => 'Vis alle',
  'Sorting' => 'Sortering',
  'Where I´m involved' => 'Hvor jeg er involveret',
);


text:
/*
 * Management API
 *
 * The version of the OpenAPI document: 1
 * Contact: developer-experience@adyen.com
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

package com.adyen.model.management;

import java.util.Objects;
import java.util.Arrays;
import com.google.gson.TypeAdapter;
import com.google.gson.annotations.JsonAdapter;
import com.google.gson.annotations.SerializedName;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.IOException;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import com.adyen.model.management.JSON;

/**
 * GiroPayInfo
 */

public class GiroPayInfo {
  public static final String SERIALIZED_NAME_SUPPORT_EMAIL = "supportEmail";
  @SerializedName(SERIALIZED_NAME_SUPPORT_EMAIL)
  private String supportEmail;

  public GiroPayInfo() {
  }

  public GiroPayInfo supportEmail(String supportEmail) {

    this.supportEmail = supportEmail;
    return this;
  }

   /**
   * The email address of merchant support.
   * @return supportEmail
  **/
  @javax.annotation.Nonnull
  @ApiModelProperty(required = true, value = "The email address of merchant support.")

  public String getSupportEmail() {
    return supportEmail;
  }

  public void setSupportEmail(String supportEmail) {
    this.supportEmail = supportEmail;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    GiroPayInfo giroPayInfo = (GiroPayInfo) o;
    return Objects.equals(this.supportEmail, giroPayInfo.supportEmail);
  }

  @Override
  public int hashCode() {
    return Objects.hash(supportEmail);
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("class GiroPayInfo {\n");
    sb.append("    supportEmail: ").append(toIndentedString(supportEmail)).append("\n");
    sb.append("}");
    return sb.toString();
  }

  /**
   * Convert the given object to string with each line indented by 4 spaces
   * (except the first line).
   */
  private String toIndentedString(Object o) {
    if (o == null) {
      return "null";
    }
    return o.toString().replace("\n", "\n    ");
  }

  public static HashSet<String> openapiFields;
  public static HashSet<String> openapiRequiredFields;

  static {
    // a set of all properties/fields (JSON key names)
    openapiFields = new HashSet<String>();
    openapiFields.add("supportEmail");

    // a set of required properties/fields (JSON key names)
    openapiRequiredFields = new HashSet<String>();
    openapiRequiredFields.add("supportEmail");
  }

 /**
  * Validates the JSON Object and throws an exception if issues found
  *
  * @param jsonObj JSON Object
  * @throws IOException if the JSON Object is invalid with respect to GiroPayInfo
  */
  public static void validateJsonObject(JsonObject jsonObj) throws IOException {
      if (jsonObj == null) {
        if (GiroPayInfo.openapiRequiredFields.isEmpty()) {
          return;
        } else { // has required fields
          throw new IllegalArgumentException(String.format("The required field(s) %s in GiroPayInfo is not found in the empty JSON string", GiroPayInfo.openapiRequiredFields.toString()));
        }
      }

      Set<Entry<String, JsonElement>> entries = jsonObj.entrySet();
      // check to see if the JSON string contains additional fields
      for (Entry<String, JsonElement> entry : entries) {
        if (!GiroPayInfo.openapiFields.contains(entry.getKey())) {
          throw new IllegalArgumentException(String.format("The field `%s` in the JSON string is not defined in the `GiroPayInfo` properties. JSON: %s", entry.getKey(), jsonObj.toString()));
        }
      }

      // check to make sure all required properties/fields are present in the JSON string
      for (String requiredField : GiroPayInfo.openapiRequiredFields) {
        if (jsonObj.get(requiredField) == null) {
          throw new IllegalArgumentException(String.format("The required field `%s` is not found in the JSON string: %s", requiredField, jsonObj.toString()));
        }
      }
      // validate the optional field supportEmail
      if (jsonObj.get("supportEmail") != null && !jsonObj.get("supportEmail").isJsonPrimitive()) {
        throw new IllegalArgumentException(String.format("Expected the field `supportEmail` to be a primitive type in the JSON string but got `%s`", jsonObj.get("supportEmail").toString()));
      }
  }

  public static class CustomTypeAdapterFactory implements TypeAdapterFactory {
    @SuppressWarnings("unchecked")
    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
       if (!GiroPayInfo.class.isAssignableFrom(type.getRawType())) {
         return null; // this class only serializes 'GiroPayInfo' and its subtypes
       }
       final TypeAdapter<JsonElement> elementAdapter = gson.getAdapter(JsonElement.class);
       final TypeAdapter<GiroPayInfo> thisAdapter
                        = gson.getDelegateAdapter(this, TypeToken.get(GiroPayInfo.class));

       return (TypeAdapter<T>) new TypeAdapter<GiroPayInfo>() {
           @Override
           public void write(JsonWriter out, GiroPayInfo value) throws IOException {
             JsonObject obj = thisAdapter.toJsonTree(value).getAsJsonObject();
             elementAdapter.write(out, obj);
           }

           @Override
           public GiroPayInfo read(JsonReader in) throws IOException {
             JsonObject jsonObj = elementAdapter.read(in).getAsJsonObject();
             validateJsonObject(jsonObj);
             return thisAdapter.fromJsonTree(jsonObj);
           }

       }.nullSafe();
    }
  }

 /**
  * Create an instance of GiroPayInfo given an JSON string
  *
  * @param jsonString JSON string
  * @return An instance of GiroPayInfo
  * @throws IOException if the JSON string is invalid with respect to GiroPayInfo
  */
  public static GiroPayInfo fromJson(String jsonString) throws IOException {
    return JSON.getGson().fromJson(jsonString, GiroPayInfo.class);
  }

 /**
  * Convert an instance of GiroPayInfo to an JSON string
  *
  * @return JSON string
  */
  public String toJson() {
    return JSON.getGson().toJson(this);
  }
}


text:
namespace anim {

SkinnedVertices::Vertex::Vertex(const Imath::V3f& pos, const Skinning& skin) : m_pos(pos), m_skinning(skin) {
}

const Imath::V3f& SkinnedVertices::Vertex::pos() const {
	return m_pos;
}

void SkinnedVertices::Vertex::setPos(const Imath::V3f& p) {
	m_pos = p;
}

const Skinning& SkinnedVertices::Vertex::skinning() const {
	return m_skinning;
}

void SkinnedVertices::Vertex::setSkinning(const Skinning& skin) {
	m_skinning = skin;
}

SkinnedVertices::Vertex& SkinnedVertices::add(const Imath::V3f& pos, const Skinning& skin) {
	m_vertices.push_back(Vertex(pos, skin));

	return m_vertices.back();
}

std::size_t SkinnedVertices::size() const {
	return m_vertices.size();
}

SkinnedVertices::Vertex& SkinnedVertices::operator[](std::size_t index) {
	return m_vertices[index];
}

const SkinnedVertices::Vertex& SkinnedVertices::operator[](std::size_t index) const {
	return m_vertices[index];
}

SkinnedVertices::const_iterator SkinnedVertices::begin() const {
	return m_vertices.begin();
}

SkinnedVertices::const_iterator SkinnedVertices::end() const {
	return m_vertices.end();
}

SkinnedVertices::iterator SkinnedVertices::begin() {
	return m_vertices.begin();
}

SkinnedVertices::iterator SkinnedVertices::end() {
	return m_vertices.end();
}

}  // namespace anim


text:
<?php
class OperatorsModel extends EmmaModel {
    public function getAll(){
        $sql = <<<SQL

		SELECT
			*
		FROM
			operators
        ORDER BY
            id DESC

SQL;

        return $this->fetchAll ($sql);
    }

}


text:
cltk.phonology.non.old\_swedish package
=======================================

.. automodule:: cltk.phonology.non.old_swedish
   :members:
   :undoc-members:
   :show-inheritance:

Submodules
----------

cltk.phonology.non.old\_swedish.phonology module
------------------------------------------------

.. automodule:: cltk.phonology.non.old_swedish.phonology
   :members:
   :undoc-members:
   :show-inheritance:

cltk.phonology.non.old\_swedish.transcription module
----------------------------------------------------

.. automodule:: cltk.phonology.non.old_swedish.transcription
   :members:
   :undoc-members:
   :show-inheritance:


text:
import { Component } from '@angular/core';
import { FieldType } from '@ngx-formly/core';

@Component({
  selector: 'formly-field-ns-textarea',
  template: `
    <TextView class="input"
      [formlyAttributes]="field"
      [formControl]="formControl"

      [hint]="to.hint"
      [autocorrect]="to.autocorrect"
      [keyboardType]="to.keyboardType">
    </TextView>
  `,
})
export class FormlyFieldTextarea extends FieldType {}


text:
package org.knowm.xchange.bitmex.dto.account;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import org.knowm.xchange.bitmex.AbstractHttpResponseAware;

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
  "account",
  "currency",
  "riskLimit",
  "prevState",
  "state",
  "action",
  "amount",
  "pendingCredit",
  "pendingDebit",
  "confirmedDebit",
  "prevRealisedPnl",
  "prevUnrealisedPnl",
  "grossComm",
  "grossOpenCost",
  "grossOpenPremium",
  "grossExecCost",
  "grossMarkValue",
  "riskValue",
  "taxableMargin",
  "initMargin",
  "maintMargin",
  "sessionMargin",
  "targetExcessMargin",
  "varMargin",
  "realisedPnl",
  "unrealisedPnl",
  "indicativeTax",
  "unrealisedProfit",
  "syntheticMargin",
  "walletBalance",
  "marginBalance",
  "marginBalancePcnt",
  "marginLeverage",
  "marginUsedPcnt",
  "excessMargin",
  "excessMarginPcnt",
  "availableMargin",
  "withdrawableMargin",
  "timestamp",
  "grossLastValue",
  "commission"
})
public final class BitmexMarginAccount extends AbstractHttpResponseAware {

  @JsonProperty("account")
  public Integer account;

  @JsonProperty("currency")
  public String currency;

  @JsonProperty("riskLimit")
  public BigDecimal riskLimit;

  @JsonProperty("prevState")
  public String prevState;

  @JsonProperty("state")
  public String state;

  @JsonProperty("action")
  public String action;

  @JsonProperty("amount")
  public BigDecimal amount;

  @JsonProperty("pendingCredit")
  public BigDecimal pendingCredit;

  @JsonProperty("pendingDebit")
  public BigDecimal pendingDebit;

  @JsonProperty("confirmedDebit")
  public BigDecimal confirmedDebit;

  @JsonProperty("prevRealisedPnl")
  public BigDecimal prevRealisedPnl;

  @JsonProperty("prevUnrealisedPnl")
  public BigDecimal prevUnrealisedPnl;

  @JsonProperty("grossComm")
  public BigDecimal grossComm;

  @JsonProperty("grossOpenCost")
  public BigDecimal grossOpenCost;

  @JsonProperty("grossOpenPremium")
  public BigDecimal grossOpenPremium;

  @JsonProperty("grossExecCost")
  public BigDecimal grossExecCost;

  @JsonProperty("grossMarkValue")
  public BigDecimal grossMarkValue;

  @JsonProperty("riskValue")
  public BigDecimal riskValue;

  @JsonProperty("taxableMargin")
  public BigDecimal taxableMargin;

  @JsonProperty("initMargin")
  public BigDecimal initMargin;

  @JsonProperty("maintMargin")
  public BigDecimal maintMargin;

  @JsonProperty("sessionMargin")
  public BigDecimal sessionMargin;

  @JsonProperty("targetExcessMargin")
  public BigDecimal targetExcessMargin;

  @JsonProperty("varMargin")
  public BigDecimal varMargin;

  @JsonProperty("realisedPnl")
  public BigDecimal realisedPnl;

  @JsonProperty("unrealisedPnl")
  public BigDecimal unrealisedPnl;

  @JsonProperty("indicativeTax")
  public BigDecimal indicativeTax;

  @JsonProperty("unrealisedProfit")
  public BigDecimal unrealisedProfit;

  @JsonProperty("syntheticMargin")
  public BigDecimal syntheticMargin;

  @JsonProperty("walletBalance")
  public BigDecimal walletBalance;

  @JsonProperty("marginBalance")
  public BigDecimal marginBalance;

  @JsonProperty("marginBalancePcnt")
  public BigDecimal marginBalancePcnt;

  @JsonProperty("marginLeverage")
  public BigDecimal marginLeverage;

  @JsonProperty("marginUsedPcnt")
  public BigDecimal marginUsedPcnt;

  @JsonProperty("excessMargin")
  public BigDecimal excessMargin;

  @JsonProperty("excessMarginPcnt")
  public BigDecimal excessMarginPcnt;

  @JsonProperty("availableMargin")
  public BigDecimal availableMargin;

  @JsonProperty("withdrawableMargin")
  public BigDecimal withdrawableMargin;

  @JsonProperty("timestamp")
  public String timestamp;

  @JsonProperty("grossLastValue")
  public BigDecimal grossLastValue;

  @JsonProperty("commission")
  public BigDecimal commission;

  @JsonIgnore private Map<String, Object> additionalProperties = new HashMap<>();

  public Integer getAccount() {
    return account;
  }

  public String getCurrency() {
    return currency;
  }

  public BigDecimal getRiskLimit() {
    return riskLimit;
  }

  public String getPrevState() {
    return prevState;
  }

  public String getState() {
    return state;
  }

  public String getAction() {
    return action;
  }

  public BigDecimal getAmount() {
    return amount;
  }

  public BigDecimal getPendingCredit() {
    return pendingCredit;
  }

  public BigDecimal getPendingDebit() {
    return pendingDebit;
  }

  public BigDecimal getConfirmedDebit() {
    return confirmedDebit;
  }

  public BigDecimal getPrevRealisedPnl() {
    return prevRealisedPnl;
  }

  public BigDecimal getPrevUnrealisedPnl() {
    return prevUnrealisedPnl;
  }

  public BigDecimal getGrossComm() {
    return grossComm;
  }

  public BigDecimal getGrossOpenCost() {
    return grossOpenCost;
  }

  public BigDecimal getGrossOpenPremium() {
    return grossOpenPremium;
  }

  public BigDecimal getGrossExecCost() {
    return grossExecCost;
  }

  public BigDecimal getGrossMarkValue() {
    return grossMarkValue;
  }

  public BigDecimal getRiskValue() {
    return riskValue;
  }

  public BigDecimal getTaxableMargin() {
    return taxableMargin;
  }

  public BigDecimal getInitMargin() {
    return initMargin;
  }

  public BigDecimal getMaintMargin() {
    return maintMargin;
  }

  public BigDecimal getSessionMargin() {
    return sessionMargin;
  }

  public BigDecimal getTargetExcessMargin() {
    return targetExcessMargin;
  }

  public BigDecimal getVarMargin() {
    return varMargin;
  }

  public BigDecimal getRealisedPnl() {
    return realisedPnl;
  }

  public BigDecimal getUnrealisedPnl() {
    return unrealisedPnl;
  }

  public BigDecimal getIndicativeTax() {
    return indicativeTax;
  }

  public BigDecimal getUnrealisedProfit() {
    return unrealisedProfit;
  }

  public BigDecimal getSyntheticMargin() {
    return syntheticMargin;
  }

  public BigDecimal getWalletBalance() {
    return walletBalance;
  }

  public BigDecimal getMarginBalance() {
    return marginBalance;
  }

  public BigDecimal getMarginBalancePcnt() {
    return marginBalancePcnt;
  }

  public BigDecimal getMarginLeverage() {
    return marginLeverage;
  }

  public BigDecimal getMarginUsedPcnt() {
    return marginUsedPcnt;
  }

  public BigDecimal getExcessMargin() {
    return excessMargin;
  }

  public BigDecimal getExcessMarginPcnt() {
    return excessMarginPcnt;
  }

  public BigDecimal getAvailableMargin() {
    return availableMargin;
  }

  public BigDecimal getWithdrawableMargin() {
    return withdrawableMargin;
  }

  public String getTimestamp() {
    return timestamp;
  }

  public BigDecimal getGrossLastValue() {
    return grossLastValue;
  }

  public BigDecimal getCommission() {
    return commission;
  }

  public Map<String, Object> getAdditionalProperties() {
    return additionalProperties;
  }
}


text:
from treadmill.infra.setup import base_provision
from treadmill.infra import configuration, constants, instances
from treadmill.api import ipa

class Node(base_provision.BaseProvision):
    def setup(
            self,
            image,
            key,
            tm_release,
            instance_type,
            app_root,
            with_api,
            ipa_admin_password,
            proid,
            subnet_name
    ):
        ldap_hostname, zk_hostname = self.hostnames_for(roles=[
            constants.ROLES['LDAP'],
            constants.ROLES['ZOOKEEPER'],
        ])

        _ipa = ipa.API()
        _node_hostnames = self._hostname_cluster(count=1)

        for _idx in _node_hostnames.keys():
            _node_h = _node_hostnames[_idx]
            otp = _ipa.add_host(hostname=_node_h)
            self.name = _node_h

            self.configuration = configuration.Node(
                tm_release=tm_release,
                app_root=app_root,
                ldap_hostname=ldap_hostname,
                otp=otp,
                with_api=with_api,
                hostname=_node_h,
                ipa_admin_password=ipa_admin_password,
                proid=proid,
                zk_url=self._zk_url(zk_hostname)
            )
            super().setup(
                image=image,
                count=1,
                key=key,
                instance_type=instance_type,
                subnet_name=subnet_name,
                sg_names=[constants.COMMON_SEC_GRP],
            )

    def destroy(self, instance_id=None):
        if instance_id:
            _instances = instances.Instances.get(ids=[instance_id])
        elif self.name:
            _instances = instances.Instances.get(
                filters=[
                    {
                        'Name': 'tag-key',
                        'Values': ['Name']
                    },
                    {
                        'Name': 'tag-value',
                        'Values': [self.name]
                    },
                ]
            )
        else:
            return

        _instances.terminate()


text:
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <CreateNewDatabase>False</CreateNewDatabase>
    <BackupDatabaseBeforeChanges>False</BackupDatabaseBeforeChanges>
    <BlockOnPossibleDataLoss>True</BlockOnPossibleDataLoss>
    <NoAlterStatementsToChangeCLRTypes>False</NoAlterStatementsToChangeCLRTypes>
    <DropObjectsNotInSource>False</DropObjectsNotInSource>
    <DeployDatabaseInSingleUserMode>False</DeployDatabaseInSingleUserMode>
    <DeployScriptFileName>Debug.sql</DeployScriptFileName>
    <ProfileVersionNumber>1</ProfileVersionNumber>
  </PropertyGroup>
</Project>


text:
/** The UI code for VPS pricing calculator */
"use strict";
(function(global) {
$(function() {

if(typeof global._translations === 'undefined') {
	global._translations = {};
}

/** */
function _(key) {
	return '' + _translations.hasOwnProperty(key) ? _translations[key] : key;
}

/** Returns the string presentation of value */
function cpu_int_to_decimal(v) {
	if(v === -2) { return 0.1; }
	if(v === -1) { return 0.2; }
	if(v === 0) { return 0.5; }
	return v;
}

/** Returns the string presentation of value */
function cpu_decimal_to_int(v) {
	if(v <= 0.1) { return -2; }
	if(v <= 0.2) { return -1; }
	if(v <= 0.0) { return 0; }
	return v;
}

/** */
function get_vps_price(provider, cpu, mem, disk, net, support, callp) {
	var c = parseInt(cpu.value, 10);
	if(c === -2) { c = 0.1; }
	else if(c === -1) { c = 0.2; }
	else if(c === 0) { c = 0.5; }

	//debug.assert(callp).is('function');

	var m = parseInt( mem.value, 10);
	var d = parseInt( disk.value, 10);
	var n = parseInt( net.value, 10);
	var s = parseInt( support.value, 10);

	return $.ajax({
		dataType: "json",
		url: 'https://sendanor.rest/products/vps?provider='+provider+'&cpu='+c+'&mem='+m+'&disk='+d+'&net='+n+'&support='+s,
		data: {},
		cache: false
	}).done(function success_handler(data) {
		//debug.assert(data).is('object');
		//console.log('data = ' + JSON.stringify(data));
		callp(undefined, data);
	}).fail(function reject_handler(data) {
		callp(data && ((data.responseJSON && data.responseJSON.error) || data.statusText) || 'ajax-error');
	});

}

/** CPU */
function CPU() {
	this.code = "cpu";
	this.name = _('label-cpu');
	this.min = -2;
	this.max = 8;
	this.step = 1;
	this.value = this.min;
}

/** Returns the string presentation of value */
CPU.prototype.getValue = function() {
	if(this.value === -2) { return 0.1; }
	if(this.value === -1) { return 0.2; }
	if(this.value === 0) { return 0.5; }
	return "" + this.value;
};

/** Returns the string presentation of value */
CPU.prototype.getDecimal = function() {
	if(this.value === -2) { return 0.1; }
	if(this.value === -1) { return 0.2; }
	if(this.value === 0) { return 0.5; }
	return this.value;
};

/** Memory */
function Mem() {
	this.code = "mem";
	this.name = _('label-mem');
	this.min = 256;
	this.max = 1024*32;
	this.step = 128;
	this.value = this.min;
}

/** Returns the string presentation of value */
Mem.prototype.getValue = function() {
	return "" + this.value;
};

/** Disk */
function Disk() {
	this.code = "disk";
	this.name = _('label-disk');
	this.min = 10;
	this.max = 1000;
	this.step = 1;
	this.value = this.min;
}

/** Returns the string presentation of value */
Disk.prototype.getValue = function() {
	return "" + this.value;
};

/** Net */
function Net() {
	this.code = "net";
	this.name = _('label-net');
	this.min = 1;
	this.max = 100000;
	this.step = 1;
	this.value = 25;
}

/** Returns the string presentation of value */
Net.prototype.getValue = function() {
	return "" + this.value;
};

/** Support class */
function Support() {
	this.code = "support";
	this.name = _('label-support');
	this.min = 1;
	this.max = 3;
	this.step = -1;
	this.value = this.max;
}

/** Returns the string presentation of value */
Support.prototype.getValue = function() {
	return "" + this.value + _('label-support-class');
};

/** */
function enable_slider(elem, param, update_data) {

	var slider = $(elem).find("."+param.code+"-slider");
	var value = $(elem).find("."+param.code+"-value");

	/** Normal slider */
	function normal_slide(v) {
		param.value = v;
		$(value).val( param.getValue() );
	}

	/** Reverse slider */
	function reverse_slide(v) {
		param.value = (param.max+param.min) - v;
		$(value).val( param.getValue() );
	}

	var slide_fun = normal_slide;
	var def_value = param.value;
	var reverse = false;
	if(param.step < 0) {
		reverse = true;
		param.step = Math.abs(param.step);
		slide_fun = reverse_slide;
		def_value = (param.max+param.min) - def_value;
	}

	$(slider).slider({
		"min": param.min,
		"max": param.max,
		"value": def_value,
		"step": param.step,
		"slide": function(event, ui) {
			slide_fun(ui.value);
			update_data();
		}
	});

	$(value).change(function() {
		var v = parseFloat( $(value).val() );
		param.value = v;
		$(slider).slider("value", param.getValue() );
		update_data();
	});

	slide_fun( $(slider).slider( "value" ) );
	update_data();

}

/** */
function update_providers(elem, data) {
	var select = $(elem).find('select.provider');
	var selected = $(select).val();
	$(select).empty();
	data.providers.forEach(function(p) {
		$(select).append( (p === selected) ? $('<option selected>').text(p) : $('<option>').text(p) );
	});
	return selected;
}

/** */
function refresh_slider(code, slider, min, max, step) {

	console.log('min = ' + min + ' max = ' + max + ' step = ' + step);

	if( (!slider) || (slider && (slider.length === 0)) ) {
		console.log('slider not found');
		return;
	}

	var value = $(slider).slider("option", "value");
	console.log('value = ' + JSON.stringify(value, null, 2) );

	if(code === "cpu") {
		value = cpu_int_to_decimal(value);
	}

	$(slider).slider("option", "min", cpu_decimal_to_int(min));
	$(slider).slider("option", "max", cpu_decimal_to_int(max));

	if(step !== undefined) {
		$(slider).slider("option", "step", step);
	}

	if(value < min) {
		$(slider).slider("option", "value", cpu_decimal_to_int(min) );
	}

	if(value > max) {
		$(slider).slider("option", "value", cpu_decimal_to_int(max) );
	}

	// this is an ugly workaround, but triggers the change event
	$(slider).slider("value", $(slider).slider("value"));

	//var values = $(slider).slider("values");
	//$(slider).slider("values", values);

	//$(slider).slider("refresh");
}

/** */
function enable_calc(elem, provider) {

	provider = provider || 'fsol';

	var cpu = new CPU();
	var mem = new Mem();
	var disk = new Disk();
	var net = new Net();
	var support = new Support();

	var _lock = false;

	function update_data() {

		if(_lock) {
			return;
		}

		_lock = true;

		$(elem).find('.result').prepend($('<i class="fa fa-spinner fa-spin">'));
		var orig_state = [provider, cpu.value, mem.value, disk.value, net.value, support.value].join('-');

		var select_provider = $(elem).find('select.provider');

		if( select_provider.length ) {
			provider = $(select_provider).val();
		}

		get_vps_price(provider, cpu, mem, disk, net, support, function(err, data) {
			try {
				if(err) {
					//debug.error(err);
					$(elem).find('.result').text( _('error-pre-content') + _(err) );
					return;
				}

				if(data.providers) {
					update_providers(elem, data);
				}

				// Update limits
				if(data.limits) {
					cpu.min = data.limits.cpu_min;
					cpu.max = data.limits.cpu_max;
					mem.min = data.limits.mem_min;
					mem.max = data.limits.mem_max;
					mem.step = data.limits.mem_step;
					disk.min = data.limits.disk_min;
					disk.max = data.limits.disk_max;
					disk.step = data.limits.disk_step;
					net.min = data.limits.net_min;
					net.max = data.limits.net_max;
					net.step = data.limits.net_step;
					support.min = data.limits.support_min;
					support.max = data.limits.support_max;

					refresh_slider( "cpu", $(elem).find('.cpu-slider'), cpu.min, cpu.max );
					refresh_slider( "mem", $(elem).find('.mem-slider'), mem.min, mem.max, mem.step );
					refresh_slider( "disk", $(elem).find('.disk-slider'), disk.min, disk.max, disk.step );
					refresh_slider( "net", $(elem).find('.net-slider'), net.min, net.max, net.step );
					refresh_slider( "support", $(elem).find('.support-slider'), support.max, support.min );
					update_data();
				}

				//debug.assert(data).is('object');
				//debug.assert(data.monthly_fee).is('number');
				$(elem).find('.result').text(''+_('product-pre-content')+
					data.provider +
					(data.model ? '/' + data.model : '') +
					' -- '+
					data.cpu + ' '+_('label-cpu')+', '+
					data.mem + ' '+_('label-mem-MB')+', '+
					data.disk + ' '+_('label-disk-GB')+', '+
					data.net + ' '+_('label-net-GB')+', '+
					data.support + _('label-support-class') +' -- '+
					data.monthly_fee + ' ' + _('eur-per-month'));

				// Update data if provider is changed
				$(elem).find('select.provider').one("change", function() {
					update_data();
				});

			} finally {
				_lock = false;

				// Check again if state has changed
				var new_state = [provider, cpu.value, mem.value, disk.value, net.value, support.value].join('-');
				if(orig_state !== new_state) {
					update_data();
				}
			}
		});
	}

	enable_slider(elem, cpu, update_data );
	enable_slider(elem, mem, update_data );
	enable_slider(elem, disk, update_data );
	enable_slider(elem, net, update_data );
	enable_slider(elem, support, update_data );

}

	enable_calc(".price-calculator");
});

})(window);


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <include
        android:id="@+id/umeng_socialize_title"
        layout="@layout/umeng_socialize_titile_bar" />

    <FrameLayout
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:background="@color/umeng_socialize_list_item_bgcolor" >

        <ScrollView
            android:id="@+id/umeng_xp_ScrollView"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:layout_gravity="center"
            android:scrollbars="none" >

            <RelativeLayout
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:paddingBottom="8dp" >

                <TextView
                    android:id="@+id/umeng_socialize_first_area_title"
                    android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:layout_marginTop="26dp"
                    android:paddingLeft="26dp"
                    android:text="分享到"
                    android:textColor="#84898f"
                    android:textSize="16sp" />

                <LinearLayout
                    android:id="@+id/umeng_socialize_first_area"
                    android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/umeng_socialize_first_area_title"
                    android:layout_centerInParent="true"
                    android:layout_marginTop="8dp"
                    android:orientation="vertical" >
                </LinearLayout>

                <TextView
                    android:id="@+id/umeng_socialize_second_area_title"
                    android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/umeng_socialize_first_area"
                    android:layout_marginTop="18dp"
                    android:paddingLeft="26dp"
                    android:text="分享到"
                    android:textColor="#84898f"
                    android:textSize="16sp"
                    android:visibility="gone" />

                <LinearLayout
                    android:id="@+id/umeng_socialize_second_area"
                    android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/umeng_socialize_second_area_title"
                    android:layout_centerInParent="true"
                    android:orientation="vertical" >
                </LinearLayout>
            </RelativeLayout>
        </ScrollView>
    </FrameLayout>

</LinearLayout>


text:
<title>Math - Untitled</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Untitled">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="prev" href="index.html#Top" title="Top">
<link rel="next" href="Complex.html#Complex" title="Complex">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<meta http-equiv="Content-Style-Type" content="text/css">

Next: Complex,
Previous: Top,
Up: Top

1 Mathematical Functions (<samp>math.h</samp>)

This chapter groups a wide variety of mathematical functions.  The
corresponding definitions and declarations are in <samp>math.h</samp>.
The definition of HUGE_VAL from <samp>math.h</samp> is of particular interest.

The representation of infinity as a double is defined as
HUGE_VAL; this number is returned on overflow by many functions.
The macro HUGE_VALF is a corresponding value for float.

Alternative declarations of the mathematical functions, which exploit
specific machine capabilities to operate faster—but generally have
less error checking and may reflect additional limitations on some
machines—are available when you include <samp>fastmath.h</samp> instead of
<samp>math.h</samp>.

version: 	Version of library

acos: 	Arccosine

acosh: 	Inverse hyperbolic cosine

asin: 	Arcsine

asinh: 	Inverse hyperbolic sine

atan: 	Arctangent

atan2: 	Arctangent of y/x

atanh: 	Inverse hyperbolic tangent

jN: 	        Bessel functions (jN, yN)

cbrt: 	Cube root

copysign: 	Sign of Y, magnitude of X

cosh: 	Hyperbolic cosine

erf: 		Error function (erf, erfc)

exp: 		Exponential, base e

exp10: 	Exponential, base 10

exp2: 	Exponential, base 2

expm1: 	Exponential, base e, of x - 1

fabs: 	Absolute value (magnitude)

fdim: 	Positive difference

floor: 	Floor and ceiling (floor, ceil)

fma: 		Floating multiply add

fmax: 	Maximum

fmin: 	Minimum

fmod: 	Floating-point remainder (modulo)

fpclassify: 	Floating-point classification macro

frexp: 	Split floating-point number

gamma: 	Logarithmic gamma function

hypot: 	Distance from origin

ilogb: 	Get exponent

infinity: 	Floating infinity

isgreater: 	Comparison macros

ldexp: 	Scale by a power of 2

log: 		Natural logarithms

log10: 	Base 10 logarithms

log1p: 	Log of 1 + X

log2: 	Base 2 logarithms

logb: 	Get exponent

lrint: 	Round to integer

lround: 	Round to integer, away from zero (lround, llround)

modf: 	Split fractional and integer parts

nan: 		Floating Not a Number

nearbyint: 	Round to integer

nextafter: 	Get next representable number

pow: 		X to the power Y

pow10: 	10 to the power X

remainder: 	remainder of X divided by Y

remquo: 	Remainder and part of quotient

rint: 	Round to integer

round: 	Round to integer, away from zero

scalbn: 	Scale by a power of FLT_RADIX (2)

signbit: 	Does floating-point number have negative sign?

sin: 		Sine or cosine (sin, cos)

sinh: 	Hyperbolic sine

sqrt: 	Positive square root

tan: 		Tangent

tanh: 	Hyperbolic tangent

trunc: 	Round to integer, towards zero


text:
class AddAssetColumnsToVideo < ActiveRecord::Migration
  def self.up
    add_column :videos, :asset_file_name, :string
    add_column :videos, :asset_content_type, :string
    add_column :videos, :asset_file_size, :integer
    add_column :videos, :asset_updated_at, :datetime
  end

  def self.down
    remove_column :videos, :asset_updated_at
    remove_column :videos, :asset_file_size
    remove_column :videos, :asset_content_type
    remove_column :videos, :asset_file_name
  end
end


text:
package mobi.bbhn.brightberry;

import net.rim.device.api.ui.Font;
import net.rim.device.api.ui.component.LabelField;
import net.rim.device.api.ui.component.RichTextField;
import net.rim.device.api.ui.component.SeparatorField;
import net.rim.device.api.ui.container.MainScreen;

public class AboutScreen extends MainScreen {
	public AboutScreen() {
        super.setTitle(new LabelField("BrightBerry About", 1152921504606846980L));
        add(new RichTextField("Version: " + BrightBerry.version));
        add(new RichTextField("Connection: " + NetworkConfig.getConnectionMode()));
        add(new SeparatorField());
        add(new RichTextField("Written by Chris Hallgren (@challgren)"));
        add(new SeparatorField());
        add(new RichTextField("Technical Consultant: Steve McGranahan (SoM)"));
        add(new SeparatorField());
        add(new RichTextField("Special Thanks to @thillerson, @doctorklein, @hiro, @sprouticus, @barkerja, @jemerick"));
        add(new SeparatorField());
        add(new RichTextField("Thank you for the following people who contributed to help fund BrightBerry: Daniel J, Andrew K, Brad T, Jayme M, Matthew H, Robert K, David C, and Marco F"));
        add(new SeparatorField());
        add(new RichTextField("Portions of code from BBPlacemarks written by Jason Emerick (@jemerick)"));
        add(new SeparatorField());
        add(new RichTextField("This is not an official Brightkite app in no way does this application represent the views or opinions of Brightkite or No Sleep Media LLC."));
        add(new SeparatorField());
        RichTextField gpswarn = new RichTextField("Using this program you are responsible for all charges associated with data/GPS usage");
        gpswarn.setFont(this.getFont().derive(Font.BOLD));
        add(gpswarn);
        add(new SeparatorField());
        add(new RichTextField("THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."));
	}
}


text:
title: Homepage Content
---

### Four core tenants keep Grav focused

We believe the best recipe to make something great, is to bake with [quality ingredients](#) and add dollops of [cool stuff](#).