text:
package test.server;

import org.wso2.carbon.event.processor.manager.commons.transport.client.TCPEventPublisher;
import org.wso2.siddhi.query.api.definition.Attribute;
import org.wso2.siddhi.query.api.definition.StreamDefinition;

import java.io.IOException;
import java.util.Random;

public class TCPEventTestClient {

    public static void main(String[] args) throws Exception {

        StreamDefinition streamDefinition = new StreamDefinition();
        streamDefinition.setId("TestStream");
        streamDefinition.attribute("att1", Attribute.Type.INT);
        streamDefinition.attribute("att2", Attribute.Type.FLOAT);
        streamDefinition.attribute("att3", Attribute.Type.STRING);
        streamDefinition.attribute("att4", Attribute.Type.INT);

        StreamDefinition streamDefinition1 = new StreamDefinition();
        streamDefinition1.setId("TestStream1");
        streamDefinition1.attribute("att1", Attribute.Type.LONG);
        streamDefinition1.attribute("att2", Attribute.Type.FLOAT);
        streamDefinition1.attribute("att3", Attribute.Type.STRING);
        streamDefinition1.attribute("att4", Attribute.Type.DOUBLE);
        streamDefinition1.attribute("att5", Attribute.Type.BOOL);
        TCPEventPublisher tcpEventPublisher = new TCPEventPublisher("localhost:7612", false, null);
        tcpEventPublisher.addStreamDefinition(streamDefinition);
        tcpEventPublisher.addStreamDefinition(streamDefinition1);

        Thread.sleep(1000);
        System.out.println("Start testing");
        Random random = new Random();

        Thread thread = new Thread(new Runner(tcpEventPublisher));
        thread.start();
//        Thread thread1 = new Thread(new Runner(TCPEventPublisher));
//        thread1.start();
//        Thread thread2 = new Thread(new Runner(TCPEventPublisher));
//        thread2.start();
    }

    static class Runner implements Runnable {

        private TCPEventPublisher tcpEventPublisher;

        Runner(TCPEventPublisher tcpEventPublisher) {
            this.tcpEventPublisher = tcpEventPublisher;
        }

        /**
         * When an object implementing interface Runnable is used
         * to create a thread, starting the thread causes the object's
         * run method to be called in that separately executing
         * thread.
         *

         * The general contract of the method run is that it may
         * take any action whatsoever.
         *
         * @see Thread#run()
         */
        @Override
        public void run() {
            for (int i = 0; i < 1000000000; i++) {
                try {
                    tcpEventPublisher.sendEvent("TestStream", System.currentTimeMillis(), new Object[]{75, 45f, "Abcdefghijklmnop", 89,}, true);
//                Thread.sleep(10000);
//                System.out.println("next");
                    tcpEventPublisher.sendEvent("TestStream1", System.currentTimeMillis(), new Object[]{90l, 77f, "Abcdefghijklmnop", 4.5, true}, true);
//                Thread.sleep(1000);
//                System.out.println("next");
                    tcpEventPublisher.sendEvent("TestStream1", System.currentTimeMillis(), new Object[]{90l, 77f, "Abcdefghijklmnop", 4.5, true}, true);
//                Thread.sleep(1000);
//                System.out.println("next");
                    tcpEventPublisher.sendEvent("TestStream1", System.currentTimeMillis(), new Object[]{90l, 77f, "Abcdefghijklmnop", 4.5, true}, true);

                } catch (IOException e) {
                    e.printStackTrace();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
                }
            }
        }
    }
}


text:
package bootstrap.liftweb

import _root_.net.liftweb.util._
import _root_.net.liftweb.common._
import _root_.net.liftweb.http._
import _root_.net.liftweb.http.provider._
import _root_.net.liftweb.sitemap._
import _root_.net.liftweb.sitemap.Loc._
import Helpers._
import _root_.net.liftweb.mapper.{DB, ConnectionManager, Schemifier, DefaultConnectionIdentifier, StandardDBVendor}
import _root_.java.sql.{Connection, DriverManager}
import _root_.${package}.model._

/**
 * A class that's instantiated early and run.  It allows the application
 * to modify lift's environment
 */
class Boot {
  def boot {
    if (!DB.jndiJdbcConnAvailable_?) {
      val vendor =
	new StandardDBVendor(Props.get("db.driver") openOr "org.h2.Driver",
			     Props.get("db.url") openOr
			     "jdbc:h2:lift_proto.db;AUTO_SERVER=TRUE",
			     Props.get("db.user"), Props.get("db.password"))

      LiftRules.unloadHooks.append(vendor.closeAllConnections_! _)

      DB.defineConnectionManager(DefaultConnectionIdentifier, vendor)
    }

    // where to search snippet
    LiftRules.addToPackages("${package}")
    Schemifier.schemify(true, Log.infoF _, User)

    // Build SiteMap
    val entries = Menu(Loc("Home", List("index"), "Home")) ::
    Menu(Loc("Static", Link(List("static"), true, "/static/index"),
	     "Static Content")) ::
    User.sitemap

    LiftRules.setSiteMap(SiteMap(entries:_*))

    /*
     * Show the spinny image when an Ajax call starts
     */
    LiftRules.ajaxStart =
      Full(() => LiftRules.jsArtifacts.show("ajax-loader").cmd)

    /*
     * Make the spinny image go away when it ends
     */
    LiftRules.ajaxEnd =
      Full(() => LiftRules.jsArtifacts.hide("ajax-loader").cmd)

    LiftRules.early.append(makeUtf8)

    LiftRules.loggedInTest = Full(() => User.loggedIn_?)

    S.addAround(DB.buildLoanWrapper)
  }

  /**
   * Force the request to be UTF-8
   */
  private def makeUtf8(req: HTTPRequest) {
    req.setCharacterEncoding("UTF-8")
  }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>PhotoSphereViewer - autorotate keypoints demo</title>

  <link rel="stylesheet" href="../dist/photo-sphere-viewer.css">
  <link rel="stylesheet" href="../dist/plugins/markers.css">
  <link rel="stylesheet" href="style.css">


text:
package com.sematext.solr.handler.component.relaxer.heuristics.regular;

import org.apache.solr.common.params.CommonParams;
import org.apache.solr.request.SolrQueryRequest;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import com.sematext.solr.handler.component.ReSearcherUtils;
import com.sematext.solr.handler.component.relaxer.QueryRelaxerHeuristic;
import com.sematext.solr.handler.component.relaxer.QueryRelaxerSuggestion;
import com.sematext.solr.handler.component.relaxer.RelaxerSuggestion;

public class RemoveOneTerm extends QueryRelaxerHeuristic {

  @Override
  public Set<RelaxerSuggestion> createSuggestions(SolrQueryRequest req) {
    List<String> words = new ArrayList<String>();

    String userQuery = req.getParams().get(CommonParams.Q);
    ReSearcherUtils.tokenizeQueryString(userQuery, words);

    if (words.size() <= 1) {
      // nothing to offer
      return null;
    } else {
      Set<RelaxerSuggestion> suggestions = new LinkedHashSet<RelaxerSuggestion>();

      for (int i = 0; i < words.size(); i++) {
        StringBuilder sug = new StringBuilder();

        for (int j = 0; j < words.size(); j++) {
          if (j != i) {
            sug.append(words.get(j).trim());
            sug.append(" ");
          }
        }

        String relaxedUserQuery = sug.toString().trim();
        suggestions.add(new QueryRelaxerSuggestion(relaxedUserQuery, userQuery, relaxedUserQuery));
      }

      return suggestions;
    }
  }
}


text:
import React, { Component, PropTypes } from 'react';
import styles from './Size.css';

import {
  SIZE_1,
  SIZE_2,
  SIZE_3,
  SIZE_4,
  SIZE_5
} from './../../../../state/markerConstants';

class Size extends Component {
  constructor(props) {
    super(props);
    this.changeSizeTo1 = props.changeSize.bind(null, SIZE_1);
    this.changeSizeTo2 = props.changeSize.bind(null, SIZE_2);
    this.changeSizeTo3 = props.changeSize.bind(null, SIZE_3);
    this.changeSizeTo4 = props.changeSize.bind(null, SIZE_4);
    this.changeSizeTo5 = props.changeSize.bind(null, SIZE_5);
  }

  render() {
    return (

        <button className={styles.dropdownButton}>
          Size: {this.props.size}
        </button>

          <span
            onClick={this.changeSizeTo1}
            className={`${styles.dropdownOption} ${styles.firstOption}`}
          >
            {SIZE_1}

            {SIZE_2}

            {SIZE_3}

            {SIZE_4}

          <span
            onClick={this.changeSizeTo5}
            className={`${styles.dropdownOption} ${styles.lastOption}`}
          >
            {SIZE_5}

    );
  }
}

Size.propTypes = {
  size: PropTypes.number.isRequired,
  changeSize: PropTypes.func.isRequired
};

export default Size;


text:
package net.bytebuddy;

import net.bytebuddy.test.utility.JavaVersionRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.MethodRule;

import java.io.Closeable;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ByteBuddySubclassDeadlockTest {

    @Rule
    public MethodRule javaVersionRule = new JavaVersionRule();

    @Test
    @JavaVersionRule.Enforce(value = 8, target = Tester.class)
    public void testDeadlock() throws Exception {
        List<URL> urls = new ArrayList<URL>();
        for (String path : System.getProperty("java.class.path").split(File.pathSeparator, -1)) {
            urls.add(new File(path).toURI().toURL());
        }
        ClassLoader classLoader = new URLClassLoader(urls.toArray(new URL[0]));
        try {
            ((Runnable) classLoader.loadClass(Tester.class.getName()).getConstructor().newInstance()).run();
        } finally {
            if (classLoader instanceof Closeable) {
                ((Closeable) classLoader).close();
            }
        }
    }

    public static class Foo {
        /* empty */
    }

    public interface Bar {
        /* empty */
    }

    public static class Tester implements Runnable {

        public void run() {
            Semaphore semaphore = new Semaphore(0);
            ExecutorService executor = Executors.newFixedThreadPool(2);
            try {
                Future<?> foo = executor.submit(new Subclassing(semaphore, Foo.class));
                Future<?> bar = executor.submit(new Subclassing(semaphore, Bar.class));
                semaphore.release(2);
                foo.get();
                bar.get();
            } catch (Exception exception) {
                throw new AssertionError(exception);
            } finally {
                executor.shutdown();
            }
        }
    }

    private static class Subclassing implements Runnable {

        private final Semaphore semaphore;

        private final Class<?> type;

        private Subclassing(Semaphore semaphore, Class<?> type) {
            this.semaphore = semaphore;
            this.type = type;
        }

        public void run() {
            try {
                semaphore.acquire();
            } catch (InterruptedException exception) {
                throw new AssertionError(exception);
            }
            new ByteBuddy().subclass(type);
        }
    }
}


text:
namespace BWSAL {

class Tinbrain : public BWAPI::AIModule
{
public:
  void onStart() override;
  void onEnd(bool isWinner) override;
  void onFrame() override;
  void onUnitDiscover(BWAPI::Unit unit) override;
  void onUnitEvade(BWAPI::Unit unit) override;
  void onUnitHide(BWAPI::Unit unit) override;
  void onUnitMorph(BWAPI::Unit unit) override;
  void onUnitRenegade(BWAPI::Unit unit) override;
  void onUnitDestroy(BWAPI::Unit unit) override;
  void onSendText(std::string text) override;

  void onUnitShow(BWAPI::Unit unit) override;
  void onNukeDetect(BWAPI::Position position) override;
  void onReceiveText(BWAPI::Player player, std::string text) override;
  void onPlayerLeft(BWAPI::Player player) override;

  ~Tinbrain(); //not part of BWAPI::AIModule
  void showStats(); //not part of BWAPI::AIModule
  void showPlayers();
  void showForces();
  bool analyzed;

  //MODULES
  std::list< BWAPI::AIModule* > m_modules;
  BWSAL::BorderManager*      m_borderManager;
  BWSAL::InformationManager* m_informationManager;
  BWSAL::BaseManager*        m_baseManager;
  BWSAL::BuildEventTimeline* m_buildEventTimeline;
  BWSAL::ReservedMap*        m_reservedMap;
  BWSAL::TaskScheduler*      m_taskScheduler;
  BWSAL::TaskExecutor*       m_taskExecutor;
  BWSAL::UnitGroupManager*   m_unitGroupManager;
  BWSAL::WorkerManager*      m_workerManager;
  BWSAL::BuildUnitManager*   m_buildUnitManager;
  BWSAL::ScoutManager*       m_scoutManager;
  //BWSAL::DefenseManager*     m_defenseManager;
  BWSAL::BuildOrderManager*  m_buildOrderManager;
  BWSAL::SupplyManager*      m_supplyManager;
  BWSAL::OffenseManager*	 m_offenseManager;
  BWSAL::BwapiEventLogger*   m_eventLogger;
  EnhancedUI*                m_enhancedUI;

  BWSAL::BuildingPlacer*     m_buildingPlacer;
  BWSAL::UnitArbitrator*     m_unitArbitrator;

  bool showManagerAssignments;
  std::string rush_mode;
};

}


text:
<?php
class Infusionsoft_FunnelService extends Infusionsoft_FunnelServiceBase{
}


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package generics;

/**
 * A dynamically allocated array which holds a collection of java.lang.Object -
 * without generic
 *
 * The MyArrayList is not type-safe. For example, if we create a MyArrayList
 * which is meant to hold String, but added in an Integer. The compiler cannot
 * detect the error. This is because MyArrayList is designed to hold Objects and
 * any Java classes can be upcast to Object.
 *
 * @author mars
 */
public class MyArrayList {

    private int size;//number of elements
    private Object[] elements;

    public MyArrayList() {//constructor
        elements = new Object[10];//allocate initial capacity of 10
        size = 0;
    }

    public void add(Object o) {
        if (size < elements.length) {
            elements[size] = o;
        } else {
            //allocate a larger array and add the element,omitted
        }
        ++size;
    }

    public Object get(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return elements[index];
    }

    public int size() {

        return size;
    }
}


text:
/*global module, require, console*/
/*jslint nomen: false*/

var express = require('express');

// Module to create the `Redis` persisted sessions.
module.exports = function () {

  console.log('Establishing session');

  // Create the `Redis` client and initialize the session store.
  var RedisStore = require('connect-redis')(express),
    redisClient = require('redis').createClient(),
    properties = require('../properties')();

  var sessionStore = global.sessionStore = new RedisStore({client: redisClient});

  var session = global.session = express.session({
    store: sessionStore,
    secret: properties.session.secret,
    maxAge: properties.session.maxAge,
    key: properties.session.key
  });

  this.use(session);
};


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE xliff PUBLIC "-//XLIFF//DTD XLIFF//EN" "http://www.oasis-open.org/committees/xliff/documents/xliff.dtd" >
<xliff version="1.0">
    <file original="global" source-language="en" datatype="plaintext">
        <header/>
        <body>
            <trans-unit>
                <source>Explorer Network</source>
                <target>Explora la xarxa</target>
            </trans-unit>
            <trans-unit>
                <source>Age</source>
                <target>Anys</target>
            </trans-unit>
            <trans-unit>
                <source>to</source>
                <target>a</target>
            </trans-unit>
            <trans-unit>
                <source>Location</source>
                <target>Ubicació</target>
            </trans-unit>
            <trans-unit>
                <source>Update</source>
                <target>Actualizar</target>
            </trans-unit>
            <trans-unit>
                <source>Results</source>
                <target>Resultats</target>
            </trans-unit>

        </body>
    </file>
</xliff>


text:
namespace utils
{
    template <typename Signature> class function;
    template <typename RC, typename ...T> class function<RC(T...)>;
}

// -----------------------------------------------------------------------------

template <typename RC, typename... T>
class utils::function<RC(T...)>
{
  private:
    struct base
    {
        virtual ~base() { }
        virtual base* clone() = 0;
        virtual RC call(T...) = 0;
    } *function_;

    template <typename Functor>
    struct concrete : base
    {
        concrete(Functor functor) : functor_(functor) { }
        base* clone() { return new concrete(*this); }
        RC call(T... a) { return functor_(a...); }

        Functor functor_;
    };

  public:
    template <typename Functor>
    function(Functor const& functor)
        : function_(new concrete<Functor>(functor))
    {
    }

    function(function const& other) : function_(other.function_->clone())
    {
    }

    function& operator=(function const& other)
    {
        function(other).swap(*this);
        return *this;
    }

    ~function()
    {
        delete function_;
    }

    void swap(function& other)
    {
        std::swap(function_, other.function_);
    }

    RC operator()(T...a) const
    {
        return function_->call(a...);
    }
};

// -----------------------------------------------------------------------------

#endif

// ----------------------------------------------------------------------------
// Copyright (C) 2014 Bloomberg Finance L.P.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ----------------------------- END-OF-FILE ----------------------------------


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

<recipeml version="0.5">
  <recipe>
    <head>
      <title>Atjar Tumis Djamur (Mushroom Pickles)</title>
      <categories>
        <cat>Relishes</cat>
        <cat>Pickles</cat>
        <cat>Indonesian</cat></categories>
      <yield>4</yield></head>
    <ingredients>
      <ing>
        <amt>
          <qty>8</qty>
          <unit>ounces</unit></amt>
        <item>Mushroom, fresh; sliced</item></ing>
      <ing>
        <amt>
          <qty>3</qty>
          <unit>ounces</unit></amt>
        <item>Shallots; slivered</item></ing>
      <ing>
        <amt>
          <qty>3</qty>
          <unit>cups</unit></amt>
        <item>Vinegar, white</item></ing>
      <ing>
        <amt>
          <qty>1</qty>
          <unit>teaspoon</unit></amt>
        <item>Cumin powder</item></ing></ingredients>
    <directions>
      <step>  Calories     per serving: 35 Fat grams per serving: 0 Approx. Cook Time:
  0:30 Heat vinegar and cumin in a non-aluminum pan until boiling. Simmer
  five minutes.  Place mushrooms and shallots in a small pan (not aluminum)
  and cover with a saucer and weight to hold it down. Pour vinegar mixture
  over mushrooms to cover.  Return pan to stove and bring to a simmer. Simmer
  10 to 15 minutes or until mushrooms are just tender. Remove from heat and
  let mushrooms cool in the vinegar. Drain and refrigerate until ready to
  serve.

  From Gemini's MASSIVE MealMaster collection at www.synapse.com/~gemini

</step></directions></recipe></recipeml>


text:
<?php

require_once 'Zend/Paginator/Adapter/Interface.php';

/**
 * @category   Zend
 * @package    Zend_Paginator
 * @subpackage UnitTests
 * @copyright  Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Zf4207 extends ArrayObject implements Zend_Paginator_Adapter_Interface
{
    public function count()
    {
        return 10;
    }

    public function getItems($pageNumber, $itemCountPerPage)
    {
        return new ArrayObject(range(1, 10));
    }
}


text:
<!DOCTYPE html>

	<meta charset="UTF-8">
	<title>Music categories</title>
	<link rel="stylesheet" href="css/style.css">

Music Categories

Even more websites all about website templates on Just Web Templates

				<button class="styled">Listen</button>
				<button class="styled">Add</button>

If you're looking for beautiful and professionally made templates you can find them at Template Beauty

				<button class="styled">Listen</button>
				<button class="styled">Add</button>

You can remove any link to our websites from this template you're free to use the template without linking back to us

				<button class="styled">Listen</button>
				<button class="styled">Add</button>


text:
using System.Web.Optimization;

namespace TotaMoviesRental
{
    public class BundleConfig
    {
        // For more information on bundling, visit http://go.microsoft.com/fwlink/?LinkId=301862
        public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/app").Include(
                "~/Scripts/app/services/customerService.js",
                "~/Scripts/app/controllers/customersController.js",
                "~/Scripts/app/app.js"
                ));

            bundles.Add(new ScriptBundle("~/bundles/lib").Include(
                         "~/Scripts/jquery-{version}.js",
                         "~/Scripts/moment.js",
                         "~/Scripts/bootstrap.js",
                         "~/Scripts/bootbox.js",
                         "~/Scripts/respond.js",
                         "~/Scripts/datatables/jquery.datatables.js",
                         "~/Scripts/datatables/datatables.bootstrap.js",
                         "~/Scripts/bootstrap-datetimepicker.js",
                         "~/Scripts/typeahead.bundle.js",
                         "~/Scripts/toastr.js"
                         ));

            bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                        "~/Scripts/jquery.validate*"));

            // Use the development version of Modernizr to develop with and learn from. Then, when you're
            // ready for production, use the build tool at http://modernizr.com to pick only the tests you need.
            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                        "~/Scripts/modernizr-*"));

            bundles.Add(new StyleBundle("~/Content/css").Include(
                      //"~/Content/bootstrap.css",
                      "~/Content/bootstrap-luman.css",
                      "~/Content/datatables/css/bootstrap-datetimepicker.css",
                      "~/Content/datatables/css/datatables.bootstrap.css",
                      "~/Content/font-awesome.css",
                      "~/Content/typeahead.css",
                      "~/Content/toastr.css",
                      "~/Content/bootstrap-overrides.css",
                      "~/Content/site.css"));
        }
    }
}


text:
@implementation UIView (Extend)
//获得某个view所在的视图控制器
- (UIViewController*)viewController {
    for (UIView* next = [self superview]; next; next = next.superview) {
        UIResponder* nextResponder = [next nextResponder];
        if ([nextResponder isKindOfClass:[UIViewController class]]) {
            return (UIViewController*)nextResponder;
        }
    }
    return nil;
}
@end


text:
package com.google.maps;

import com.google.maps.internal.ApiConfig;
import com.google.maps.internal.StringJoin;
import com.google.maps.internal.StringJoin.UrlValue;
import com.google.maps.model.EncodedPolyline;
import com.google.maps.model.LatLng;
import com.google.maps.model.Size;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

public class StaticMapsRequest
    extends PendingResultBase<ImageResult, StaticMapsRequest, ImageResult.Response> {

  static final ApiConfig API_CONFIG = new ApiConfig("/maps/api/staticmap");

  public StaticMapsRequest(GeoApiContext context) {
    super(context, API_CONFIG, ImageResult.Response.class);
  }

  @Override
  protected void validateRequest() {
    if (!((params().containsKey("center") && params().containsKey("zoom"))
        || params().containsKey("markers"))) {
      throw new IllegalArgumentException(
          "Request must contain 'center' and 'zoom' if 'markers' isn't present.");
    }
    if (!params().containsKey("size")) {
      throw new IllegalArgumentException("Request must contain 'size'.");
    }
  }

  /**
   * center (required if markers not present) defines the center of the map,
   * equidistant from all edges of the map.
   *
   * @param location The location of the center of the map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest center(LatLng location) {
    return param("center", location);
  }

  /**
   * center (required if markers not present) defines the center of the map,
   * equidistant from all edges of the map.
   *
   * @param location The location of the center of the map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest center(String location) {
    return param("center", location);
  }

  /**
   * zoom (required if markers not present) defines the zoom level of the map, which
   * determines the magnification level of the map.
   *
   * @param zoom The zoom level of the region.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest zoom(int zoom) {
    return param("zoom", zoom);
  }

  /**
   * size defines the rectangular dimensions of the map image.
   *
   * @param size The Size of the static map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest size(Size size) {
    return param("size", size);
  }

  /**
   * scale affects the number of pixels that are returned. Setting scale
   * to 2 returns twice as many pixels as scale set to 1 while retaining the same
   * coverage area and level of detail (i.e. the contents of the map doesn't change).
   *
   * @param scale The scale of the static map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest scale(int scale) {
    return param("scale", scale);
  }

  public enum ImageFormat implements UrlValue {
    png("png"),
    png8("png8"),
    png32("png32"),
    gif("gif"),
    jpg("jpg"),
    jpgBaseline("jpg-baseline");

    private final String format;

    ImageFormat(String format) {
      this.format = format;
    }

    @Override
    public String toUrlValue() {
      return format;
    }
  }

  /**
   * format defines the format of the resulting image. By default, the Google Static
   * Maps API creates PNG images. There are several possible formats including GIF, JPEG and PNG
   * types.
   *
   * @param format The format of the static map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest format(ImageFormat format) {
    return param("format", format);
  }

  public enum StaticMapType implements UrlValue {
    roadmap,
    satellite,
    terrain,
    hybrid;

    @Override
    public String toUrlValue() {
      return this.name();
    }
  }

  /**
   * maptype defines the type of map to construct.
   *
   * @param maptype The map type of the static map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest maptype(StaticMapType maptype) {
    return param("maptype", maptype);
  }

  /**
   * region defines the appropriate borders to display, based on geo-political
   * sensitivities. Accepts a region code specified as a two-character ccTLD ('top-level domain')
   * value.
   *
   * @param region The region of the static map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest region(String region) {
    return param("region", region);
  }

  public static class Markers implements UrlValue {

    public enum MarkersSize implements UrlValue {
      tiny,
      mid,
      small,
      normal;

      @Override
      public String toUrlValue() {
        return this.name();
      }
    }

    public enum CustomIconAnchor implements UrlValue {
      top,
      bottom,
      left,
      right,
      center,
      topleft,
      topright,
      bottomleft,
      bottomright;

      @Override
      public String toUrlValue() {
        return this.name();
      }
    }

    private MarkersSize size;
    private String color;
    private String label;
    private String customIconURL;
    private CustomIconAnchor anchorPoint;
    private Integer scale;
    private final List<String> locations = new ArrayList<>();

    /**
     * Specifies the size of marker. If no size parameter is set, the marker will appear in its
     * default (normal) size.
     *
     * @param size The size of the markers.
     */
    public void size(MarkersSize size) {
      this.size = size;
    }

    /**
     * Specifies a 24-bit color (example: color=0xFFFFCC) or a predefined color from the set {black,
     * brown, green, purple, yellow, blue, gray, orange, red, white}.
     *
     * @param color The color of the markers.
     */
    public void color(String color) {
      this.color = color;
    }

    private static final Pattern labelPattern = Pattern.compile("^[A-Z0-9]$");

    /**
     * Specifies a single uppercase alphanumeric character from the set {A-Z, 0-9}.
     *
     * @param label The label to add to markers.
     */
    public void label(String label) {
      if (!labelPattern.matcher(label).matches()) {
        throw new IllegalArgumentException(
            "Label '" + label + "' doesn't match acceptable label pattern.");
      }

      this.label = label;
    }

    /**
     * Set a custom icon for these markers.
     *
     * @param url URL for the custom icon.
     * @param anchorPoint The anchor point for this custom icon.
     */
    public void customIcon(String url, CustomIconAnchor anchorPoint) {
      this.customIconURL = url;
      this.anchorPoint = anchorPoint;
    }

    /**
     * Set a custom icon for these markers.
     *
     * @param url URL for the custom icon.
     * @param anchorPoint The anchor point for this custom icon.
     * @param scale Set the image density scale (1, 2, or 4) of the custom icon provided.
     */
    public void customIcon(String url, CustomIconAnchor anchorPoint, int scale) {
      this.customIconURL = url;
      this.anchorPoint = anchorPoint;
      this.scale = scale;
    }

    /**
     * Add the location of a marker. At least one is required.
     *
     * @param location The location of the added marker.
     */
    public void addLocation(String location) {
      locations.add(location);
    }

    /**
     * Add the location of a marker. At least one is required.
     *
     * @param location The location of the added marker.
     */
    public void addLocation(LatLng location) {
      locations.add(location.toUrlValue());
    }

    @Override
    public String toUrlValue() {
      List<String> urlParts = new ArrayList<>();

      if (customIconURL != null) {
        urlParts.add("icon:" + customIconURL);
      }

      if (anchorPoint != null) {
        urlParts.add("anchor:" + anchorPoint.toUrlValue());
      }

      if (scale != null) {
        urlParts.add("scale:" + scale);
      }

      if (size != null && size != MarkersSize.normal) {
        urlParts.add("size:" + size.toUrlValue());
      }

      if (color != null) {
        urlParts.add("color:" + color);
      }

      if (label != null) {
        urlParts.add("label:" + label);
      }

      urlParts.addAll(locations);

      return StringJoin.join('|', urlParts.toArray(new String[urlParts.size()]));
    }
  }

  /**
   * markers parameter defines a set of one or more markers (map pins) at a set of
   * locations. Each marker defined within a single markers declaration must exhibit the same visual
   * style; if you wish to display markers with different styles, you will need to supply multiple
   * markers parameters with separate style information.
   *
   * @param markers A group of markers with the same style.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest markers(Markers markers) {
    return paramAddToList("markers", markers);
  }

  public static class Path implements UrlValue {

    private int weight;
    private String color;
    private String fillcolor;
    private boolean geodesic;
    private final List<String> points = new ArrayList<>();

    /**
     * Specifies the thickness of the path in pixels. If no weight parameter is set, the path will
     * appear in its default thickness (5 pixels).
     *
     * @param weight The thickness of the path in pixels.
     */
    public void weight(int weight) {
      this.weight = weight;
    }

    /**
     * Specifies a 24-bit color (example: color=0xFFFFCC) or a predefined color from the set {black,
     * brown, green, purple, yellow, blue, gray, orange, red, white}.
     *
     * @param color The color of the path.
     */
    public void color(String color) {
      this.color = color;
    }

    /**
     * Specifies a 24-bit color (example: color=0xFFFFCC) or a predefined color from the set {black,
     * brown, green, purple, yellow, blue, gray, orange, red, white}.
     *
     * @param color The fill color.
     */
    public void fillcolor(String color) {
      this.fillcolor = color;
    }

    /**
     * Indicates that the requested path should be interpreted as a geodesic line that follows the
     * curvature of the earth.
     *
     * @param geodesic Whether the path is geodesic.
     */
    public void geodesic(boolean geodesic) {
      this.geodesic = geodesic;
    }

    /**
     * Add a point to the path. At least two are required.
     *
     * @param point The point to add.
     */
    public void addPoint(String point) {
      points.add(point);
    }

    /**
     * Add a point to the path. At least two are required.
     *
     * @param point The point to add.
     */
    public void addPoint(LatLng point) {
      points.add(point.toUrlValue());
    }

    @Override
    public String toUrlValue() {
      List<String> urlParts = new ArrayList<>();

      if (weight > 0) {
        urlParts.add("weight:" + weight);
      }

      if (color != null) {
        urlParts.add("color:" + color);
      }

      if (fillcolor != null) {
        urlParts.add("fillcolor:" + fillcolor);
      }

      if (geodesic) {
        urlParts.add("geodesic:" + geodesic);
      }

      urlParts.addAll(points);

      return StringJoin.join('|', urlParts.toArray(new String[urlParts.size()]));
    }
  }

  /**
   * The path parameter defines a set of one or more locations connected by a path to
   * overlay on the map image.
   *
   * @param path A path to render atop the map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest path(Path path) {
    return paramAddToList("path", path);
  }

  /**
   * The path parameter defines a set of one or more locations connected by a path to
   * overlay on the map image. This variant of the method accepts the path as an EncodedPolyline.
   *
   * @param path A path to render atop the map, as an EncodedPolyline.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest path(EncodedPolyline path) {
    return paramAddToList("path", "enc:" + path.getEncodedPath());
  }

  /**
   * visible instructs the Google Static Maps API service to construct a map such that
   * the existing locations remain visible.
   *
   * @param visibleLocation The location to be made visible in the requested Static Map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest visible(LatLng visibleLocation) {
    return param("visible", visibleLocation);
  }

  /**
   * visible instructs the Google Static Maps API service to construct a map such that
   * the existing locations remain visible.
   *
   * @param visibleLocation The location to be made visible in the requested Static Map.
   * @return Returns this {@code StaticMapsRequest} for call chaining.
   */
  public StaticMapsRequest visible(String visibleLocation) {
    return param("visible", visibleLocation);
  }
}


text:
namespace BundleTransformer.TypeScript.Constants
{
	/// <summary>
	/// Asset type code constants
	/// </summary>
	public static class AssetTypeCode
	{
		/// <summary>
		/// TypeScript asset
		/// </summary>
		public static readonly string TypeScript = "TypeScript";
	}
}


text:
<?php namespace CompareAsiaGroup\Registry;

use Illuminate\Support\ServiceProvider;

class RegistryServiceProvider extends ServiceProvider {

	/**
	 * Indicates if loading of the provider is deferred.
	 *
	 * @var bool
	 */
	protected $defer = false;

	/**
	 * Bootstrap the application events.
	 *
	 * @return void
	 */
	public function boot()
	{
        $this->publishes([
            __DIR__.'/../../config/registry.php' => config_path('registry.php'),
        ]);

    }

	/**
	 * Register the service provider.
	 *
	 * @return void
	 */
	public function register()
	{
		$this->registerRegistry();
	}

    /**
     * Register the collection repository.
     *
     * @return void
     */
    protected function registerRegistry()
    {
        $this->app['registry'] = $this->app->share(function($app)
        {
            $config = $app->config->get('registry', array());

            return new Registry($config);
        });
    }

	/**
	 * Get the services provided by the provider.
	 *
	 * @return array
	 */
	public function provides()
	{
		return array('registry');
	}

}


text:
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Gfycat.Rest;
using System.Net;
using System.Linq;

[assembly: CLSCompliant(true)]

namespace Gfycat.Analytics
{
    /// <summary>
    /// Represents a client for communicating with the Gfycat analytics API. See https://developers.gfycat.com/analytics for info on when to use this client
    /// </summary>
    public class GfycatAnalyticsClient
    {
        internal GfycatAnalyticsClientConfig Config { get; }

        /// <summary>
        /// Gets the current user's tracking cookie
        /// </summary>
        public string CurrentUserTrackingCookie { get; private set; } = GfycatAnalyticsClientConfig.GenerateCookie();

        /// <summary>
        /// Creates a new client using the specified app name, app Id, app version, and user tracking cookie
        /// </summary>
        /// <param name="appName"></param>
        /// <param name="appId"></param>
        /// <param name="appVersion"></param>
        /// <param name="userTrackingCookie"></param>
        public GfycatAnalyticsClient(string appName, string appId, Version appVersion, string userTrackingCookie)
        {
            Config = new GfycatAnalyticsClientConfig(appName, appId, appVersion);
            CurrentUserTrackingCookie = userTrackingCookie;
        }

        /// <summary>
        /// Creates a new client using the specified config and user tracking cookie
        /// </summary>
        /// <param name="config"></param>
        /// <param name="userTrackingCookie"></param>
        public GfycatAnalyticsClient(GfycatAnalyticsClientConfig config, string userTrackingCookie)
        {
            Config = config;
            CurrentUserTrackingCookie = userTrackingCookie;
        }

        private async Task<RestResponse> SendInternalAsync(string method, string endpoint, RequestOptions options)
        {
            RestResponse response = null;
            bool retry = true;
            while (retry)
            {
                try
                {
                    response = await Config.RestClient.SendAsync(method, endpoint, options.CancellationToken).TimeoutAfter(options.Timeout);
                }
                catch(TimeoutException) when (options.RetryMode == RetryMode.RetryTimeouts)
                {
                    continue;
                }
                if (response.Status == HttpStatusCode.BadGateway && !options.RetryMode.HasFlag(RetryMode.Retry502))
                    throw await GfycatException.CreateFromResponseAsync(response);
                else
                {
                    if (!response.Status.IsSuccessfulStatus() && !(options.IgnoreCodes?.Any(code => code == response.Status) ?? false))
                    {
                        throw await GfycatException.CreateFromResponseAsync(response);
                    }
                    retry = false;
                }
            }

            return response;
        }

        #region Impressions

        private async Task<RestResponse> SendImpressionInternalAsync(Impression impression, RequestOptions options)
        {
            if (impression == null)
                throw new ArgumentNullException(nameof(impression), "The provided impression can't be null!");

            return await SendInternalAsync("POST", GfycatAnalyticsClientConfig.BaseImpressionsUrl + impression.CreateQuery(this), options);
        }

        private async Task<RestResponse> SendImpressionsBulkInternalAsync(IEnumerable<Impression> impressions, RequestOptions options)
        {
            impressions = impressions.Where(impression => impression != null);

            if (impressions.Count() == 0)
                throw new ArgumentException("You can't post an impression for nothing!");

            return await SendInternalAsync("POST", GfycatAnalyticsClientConfig.BaseImpressionsUrl + impressions.CreateQuery(this), options);
        }

        /// <summary>
        /// Sends an impression using the specified gfy, context, flow, view tag, and keyword
        /// </summary>
        /// <param name="gfy"></param>
        /// <param name="context"></param>
        /// <param name="flow"></param>
        /// <param name="viewTag"></param>
        /// <param name="keyword"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendImpressionAsync(Gfy gfy, ImpressionContext context = ImpressionContext.None, ImpressionFlow flow = ImpressionFlow.None, string viewTag = null, string keyword = null, RequestOptions options = null)
        {
            await SendImpressionAsync(new Impression
            {
                Gfycat = gfy,
                Context = context,
                Flow = flow,
                Keyword = keyword,
                ViewTag = viewTag
            }, options);
        }

        /// <summary>
        /// Sends one impression to Gfycat impressions
        /// </summary>
        /// <param name="impression"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendImpressionAsync(Impression impression, RequestOptions options = null)
        {
            await SendImpressionInternalAsync(impression, options);
        }

        /// <summary>
        /// Sends multiple impressions to Gfycat impressions
        /// </summary>
        /// <param name="impressions"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendImpressionsBulkAsync(IEnumerable<Impression> impressions, RequestOptions options = null)
        {
            await SendImpressionsBulkInternalAsync(impressions, options);
        }

        #endregion

        #region Analytics

        readonly static IReadOnlyDictionary<AnalyticsEvent, string> _eventsToString = new Dictionary<AnalyticsEvent, string>
        {
            { AnalyticsEvent.AppFirstLaunch, "first_launch" },
            { AnalyticsEvent.BookmarkVideo, "bookmark_video" },
            { AnalyticsEvent.CaptionVideos, "caption_video" },
            { AnalyticsEvent.CopyLink, "copy_link" },
            { AnalyticsEvent.CreateVideo, "create_video" },
            { AnalyticsEvent.DownloadVideo, "download_video" },
            { AnalyticsEvent.ScrollInCategories, "scroll_in_categories" },
            { AnalyticsEvent.ScrollInVideos, "scoll_in_videos" },
            { AnalyticsEvent.SearchVideo, "search_videos" },
            { AnalyticsEvent.SelectCategory, "tap_category" },
            { AnalyticsEvent.ShareGfy, "send_video" }
        };

        private async Task<RestResponse> SendAnalyticsInternalAsync(AnalyticsEvent aEvent, RequestOptions options, params (string, object)[] data)
        {
            return await SendInternalAsync("POST", GfycatAnalyticsClientConfig.BaseAnalyticsUrl + Utils.CreateQueryString(
                new(string, object)[]
                {
                    ("event", _eventsToString[aEvent]),
                    ("app", Config.AppName),
                    ("app_id", Config.AppId),
                    ("ver", Config.AppVersion.ToString())
                }.Concat(data).ToArray()
                ), options);
        }
        /// <summary>
        /// Sends a first launch event to Gfycat analytics
        /// </summary>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendAppFirstLaunchEventAsync(RequestOptions options = null)
        {
            await SendAnalyticsInternalAsync(AnalyticsEvent.AppFirstLaunch, options, ("utc", CurrentUserTrackingCookie));
        }
        /// <summary>
        /// Sends a video share event to Gfycat analytics
        /// </summary>
        /// <param name="gfy"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendShareVideoEventAsync(Gfy gfy, RequestOptions options = null)
        {
            if (gfy == null)
                throw new ArgumentNullException("The provided Gfy was null");

            await SendAnalyticsInternalAsync(AnalyticsEvent.ShareGfy, options, ("utc", CurrentUserTrackingCookie), ("gfyid", gfy.Id));
        }
        /// <summary>
        /// Sends a tap category event to Gfycat analytics
        /// </summary>
        /// <param name="keyword"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendTapCategoryEventAsync(string keyword, RequestOptions options = null)
        {
            if (string.IsNullOrWhiteSpace(keyword))
                throw new ArgumentException("The provided keyword is invalid!");

            await SendAnalyticsInternalAsync(AnalyticsEvent.SelectCategory, options, ("utc", CurrentUserTrackingCookie), ("keyword", keyword));
        }
        /// <summary>
        /// Sends a video creation event to Gfycat analytics
        /// </summary>
        /// <param name="videoLengthMilliseconds"></param>
        /// <param name="cameraDirection"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendCreateVideoEventAsync(int? videoLengthMilliseconds = null, CameraDirection? cameraDirection = null, RequestOptions options = null)
        {
            await SendAnalyticsInternalAsync(AnalyticsEvent.CreateVideo, options, ("utc", CurrentUserTrackingCookie), ("length", videoLengthMilliseconds), ("context", cameraDirection == CameraDirection.None ? null : cameraDirection));
        }

        /// <summary>
        /// Sends a search videos event to Gfycat analytics
        /// </summary>
        /// <param name="keyword"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendSearchVideosEventAsync(string keyword, RequestOptions options = null)
        {
            if (string.IsNullOrWhiteSpace(keyword))
                throw new ArgumentException("The provided keyword is invalid!");

            await SendAnalyticsInternalAsync(AnalyticsEvent.SearchVideo, options, ("utc", CurrentUserTrackingCookie), ("keyword", keyword));
        }

        /// <summary>
        /// Sends a scoll in categories event to Gfycat analytics
        /// </summary>
        /// <param name="count"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendScrollInCategoriesEventAsync(int count, RequestOptions options = null)
        {
            await SendAnalyticsInternalAsync(AnalyticsEvent.ScrollInCategories, options, ("utc", CurrentUserTrackingCookie), ("count", count));
        }

        /// <summary>
        /// Sends a scroll in videos event to Gfycat analytics
        /// </summary>
        /// <param name="count"></param>
        /// <param name="context"></param>
        /// <param name="keyword"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendScrollInVideosEventAsync(int count, ImpressionContext context = ImpressionContext.None, string keyword = null, RequestOptions options = null)
        {
            await SendAnalyticsInternalAsync(AnalyticsEvent.ScrollInVideos, options, ("utc", CurrentUserTrackingCookie), ("count", count), ("context", (context == ImpressionContext.None ? null : context.ToString())), ("keyword", keyword));
        }

        /// <summary>
        /// Sends a video caption event to Gfycat analytics
        /// </summary>
        /// <param name="captionText"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendCaptionVideoEventAsync(string captionText, RequestOptions options = null)
        {
            if (captionText == null)
                throw new ArgumentNullException("The caption text is null!");

            await SendAnalyticsInternalAsync(AnalyticsEvent.CaptionVideos, options, ("utc", CurrentUserTrackingCookie), ("text", captionText));
        }

        /// <summary>
        /// Sends a copy link event to Gfycat analytics
        /// </summary>
        /// <param name="gfy"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendCopyLinkEventAsync(Gfy gfy, RequestOptions options = null)
        {
            if (gfy == null)
                throw new ArgumentNullException("The provided Gfy was null");

            await SendAnalyticsInternalAsync(AnalyticsEvent.CopyLink, options, ("utc", CurrentUserTrackingCookie), ("gfyid", gfy.Id));
        }

        /// <summary>
        /// Sends a download video event to Gfycat analytics
        /// </summary>
        /// <param name="gfy"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendDownloadVideoEventAsync(Gfy gfy, RequestOptions options = null)
        {
            if (gfy == null)
                throw new ArgumentNullException("The provided Gfy was null");

            await SendAnalyticsInternalAsync(AnalyticsEvent.DownloadVideo, options, ("utc", CurrentUserTrackingCookie), ("gfyid", gfy.Id));
        }

        /// <summary>
        /// Sends a bookmark video event to Gfycat analytics
        /// </summary>
        /// <param name="gfy"></param>
        /// <param name="options">The options for this request</param>
        /// <returns></returns>
        public async Task SendBookmarkVideoEventAsync(Gfy gfy, RequestOptions options = null)
        {
            if (gfy == null)
                throw new ArgumentNullException("The provided Gfy was null");

            await SendAnalyticsInternalAsync(AnalyticsEvent.BookmarkVideo, options, ("utc", CurrentUserTrackingCookie), ("gfyid", gfy.Id));
        }

        #endregion
    }
}


text:
/* jshint indent: 2 */

module.exports = function(sequelize, DataTypes) {
  return sequelize.define('phpbb_posts_archive', {
    post_id: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      primaryKey: true,
      autoIncrement: true
    },
    topic_id: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      defaultValue: "0"
    },
    forum_id: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      defaultValue: "0"
    },
    poster_id: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      defaultValue: "0"
    },
    icon_id: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      defaultValue: "0"
    },
    poster_ip: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_time: {
      type: DataTypes.INTEGER(11),
      allowNull: false,
      defaultValue: "0"
    },
    post_approved: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    post_reported: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "0"
    },
    enable_bbcode: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    enable_smilies: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    enable_magic_url: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    enable_sig: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    post_username: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_subject: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_text: {
      type: DataTypes.TEXT,
      allowNull: false
    },
    post_checksum: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_attachment: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "0"
    },
    bbcode_bitfield: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    bbcode_uid: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_postcount: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "1"
    },
    post_edit_time: {
      type: DataTypes.INTEGER(11),
      allowNull: false,
      defaultValue: "0"
    },
    post_edit_reason: {
      type: DataTypes.STRING,
      allowNull: false,
      defaultValue: ""
    },
    post_edit_user: {
      type: DataTypes.INTEGER(8),
      allowNull: false,
      defaultValue: "0"
    },
    post_edit_count: {
      type: DataTypes.INTEGER(4),
      allowNull: false,
      defaultValue: "0"
    },
    post_edit_locked: {
      type: DataTypes.INTEGER(1),
      allowNull: false,
      defaultValue: "0"
    }
  }, {
    tableName: 'phpbb_posts_archive'
  });
};


text:
// Copyright 2004, 2005 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package gaderian.test.services;

/**
 * Used to test how the BuilderFactory invokes an initialize method.
 *
 * @author Howard Lewis Ship
 */
public class InitializeFixture
{
    private String _method;

    public void initializeService()
    {
        _method = "initializeService";
    }

    public void initializeCustom()
    {
        _method = "initializeCustom";
    }

    public String getMethod()
    {
        return _method;
    }
}


text:
#include <itkMetaDataTensorImageReader.h>

#include <medAbstractData.h>
#include <medAbstractDataFactory.h>

#include <itkMetaImageIO.h>

const char itkMetaDataTensorImageReader::ID[] = "itkMetaDataTensorImageReader";

itkMetaDataTensorImageReader::itkMetaDataTensorImageReader(): itkDataTensorImageReaderBase() {
    this->io = itk::MetaImageIO::New();
}

itkMetaDataTensorImageReader::~itkMetaDataTensorImageReader() { }

bool itkMetaDataTensorImageReader::registered() {
  return medAbstractDataFactory::instance()->registerDataReaderType(ID,itkDataTensorImageReaderBase::s_handled(),
								    createItkMetaDataTensorImageReader);
}

QString itkMetaDataTensorImageReader::identifier() const {
    return ID;
}

QString itkMetaDataTensorImageReader::description() const {
    return "Reader for meta data tensor images";
}

// /////////////////////////////////////////////////////////////////
// Type instantiation
// /////////////////////////////////////////////////////////////////

dtkAbstractDataReader *createItkMetaDataTensorImageReader() {
    return new itkMetaDataTensorImageReader;
}


text:
'use strict';

exports.__esModule = true;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactDom = require('react-dom');

var _reactDom2 = _interopRequireDefault(_reactDom);

var _moment = require('moment');

var _moment2 = _interopRequireDefault(_moment);

var _lodashOmit = require('lodash/omit');

var _lodashOmit2 = _interopRequireDefault(_lodashOmit);

var _DatePicker = require('./DatePicker');

var _DatePicker2 = _interopRequireDefault(_DatePicker);

var _utilsDateUtils = require('./utils/DateUtils');

var _utilsDateUtils2 = _interopRequireDefault(_utilsDateUtils);

var _utilsFormatMixin = require('./utils/formatMixin');

var _utilsFormatMixin2 = _interopRequireDefault(_utilsFormatMixin);

var _classnames = require('classnames');

var _classnames2 = _interopRequireDefault(_classnames);

var _utilsValueLinkMixinJs = require('./utils/ValueLinkMixin.js');

var _utilsValueLinkMixinJs2 = _interopRequireDefault(_utilsValueLinkMixinJs);

var INVALID = 'Invalid date';
var ENTER_KEYCODE = 13;

var propTypes = {
  onChange: _react.PropTypes.func,
  onShow: _react.PropTypes.func,
  onHide: _react.PropTypes.func,
  value: _utilsDateUtils2['default'].evaluateDateProp,
  valueLink: _react.PropTypes.shape({
    value: _utilsDateUtils2['default'].evaluateDateProp,
    requestChange: _react.PropTypes.func.isRequired
  }),
  defaultValue: _utilsDateUtils2['default'].evaluateDateProp,
  minDate: _utilsDateUtils2['default'].evaluateDateProp,
  maxDate: _utilsDateUtils2['default'].evaluateDateProp,
  locale: _react.PropTypes.string,
  startMode: _react.PropTypes.string,
  fixedMode: _react.PropTypes.bool,
  displayFormat: _react.PropTypes.string,
  returnFormat: _react.PropTypes.string,
  format: _react.PropTypes.string,
  validationFormat: _react.PropTypes.string,
  showOnInputClick: _react.PropTypes.bool,
  closeOnClickOutside: _react.PropTypes.bool,
  showInputButton: _react.PropTypes.bool,
  autoClose: _react.PropTypes.bool,
  floating: _react.PropTypes.bool,
  iconClassName: _react.PropTypes.string,
  iconClearClassName: _react.PropTypes.string,
  onClear: _react.PropTypes.func,
  className: _react.PropTypes.string, // used to omit from inputProps
  style: _react.PropTypes.object // used to omit from inputProps
};

var DatePickerInput = _react2['default'].createClass({
  displayName: 'DatePickerInput',

  propTypes: propTypes,

  mixins: [_utilsValueLinkMixinJs2['default'], _utilsFormatMixin2['default']],

  getDefaultProps: function getDefaultProps() {
    return {
      onShow: function onShow() {},
      onHide: function onHide() {},
      startMode: 'day',
      autoClose: true,
      closeOnClickOutside: true,
      floating: true,
      showInputButton: true,
      iconClassName: '',
      className: '',
      style: {}
    };
  },

  getInitialState: function getInitialState() {
    var _date = this.getValueLink().value || this.props.defaultValue;
    var date = typeof _date === 'string' ? this.parsePropDateString(_date) : _moment2['default'](_date);
    return {
      date: _date ? date : undefined,
      dateString: _date ? this.formatDisplayedDate(date) : '',
      showing: false
    };
  },

  componentDidMount: function componentDidMount() {
    if (this.props.closeOnClickOutside) {
      this.addOnClickListener();
    }
  },

  addOnClickListener: function addOnClickListener() {
    if (window.attachEvent) {
      //Internet Explorer
      window.attachEvent('onclick', this.hideOnClickOutside);
    } else if (window.addEventListener) {
      window.addEventListener('click', this.hideOnClickOutside, false);
    }
  },

  removeOnClickListener: function removeOnClickListener() {
    if (window.detachEvent) {
      //Internet Explorer
      window.detachEvent('onclick', this.hideOnClickOutside);
    } else if (window.removeEventListener) {
      window.removeEventListener('click', this.hideOnClickOutside, false);
    }
  },

  getDatePickerInput: function getDatePickerInput() {
    return _reactDom2['default'].findDOMNode(this.refs.datePickerInput);
  },

  isEventInsideDatePickerInput: function isEventInsideDatePickerInput(el) {
    if (el === this.getDatePickerInput()) {
      return true;
    } else if (el.parentNode) {
      return this.isEventInsideDatePickerInput(el.parentNode);
    } else {
      return false;
    }
  },

  hideOnClickOutside: function hideOnClickOutside(e) {
    if (!this.isEventInsideDatePickerInput(e.target) && this.state.showing) {
      this.hide();
    }
  },

  hide: function hide() {
    this.setState({ showing: false }, this.props.onHide);
  },

  show: function show() {
    if (!this.state.showing) {
      this.setState({ showing: true }, this.props.onShow);
    }
  },

  toggleDatePicker: function toggleDatePicker() {
    var callback = this.state.showing ? this.props.onHide : this.props.onShow;
    this.setState({ showing: !this.state.showing }, callback);
  },

  hideOnEnterKey: function hideOnEnterKey(event) {
    if (event.keyCode === ENTER_KEYCODE) {
      this.hide();
    }
  },

  onClear: function onClear() {
    var _date = this.props.defaultValue;
    var date = typeof _date === 'string' ? this.parsePropDateString(_date) : _moment2['default'](_date);
    this.setState({
      date: _date ? date : undefined,
      dateString: _date ? this.formatDisplayedDate(date) : '',
      showing: false
    }, this.props.onClear);
  },

  _onChangeDate: function _onChangeDate(jsDate) {
    var newDate = _moment2['default'](jsDate);
    var newDateString = this.formatDisplayedDate(newDate);
    if (this.props.autoClose) {
      this.hide();
    }
    this.getValueLink().requestChange(jsDate, this.formatReturnedDate(newDate));
    if (newDateString !== this.state.dateString) {
      this.setState({
        date: newDate,
        dateString: newDateString
      });
    }
  },

  onChangeInput: function onChangeInput(dateString) {
    var _this = this;

    var parsedDate = this.parseInputDateString(dateString);
    var date = parsedDate.isValid() ? parsedDate : this.state.date;

    var jsDate = parsedDate.isValid() ? parsedDate.toDate() : INVALID;
    var returnedDateString = jsDate ? this.formatReturnedDate(parsedDate) : INVALID;

    this.setState({ dateString: dateString, date: date }, function () {
      return _this.getValueLink().requestChange(jsDate, returnedDateString);
    });
  },

  getDatePicker: function getDatePicker() {
    if (this.state.showing) {
      return _react2['default'].createElement(_DatePicker2['default'], {
        value: this.state.date ? this.state.date.toDate() : undefined,
        onChange: this._onChangeDate,
        defaultValue: this.props.defaultValue,
        minDate: this.props.minDate,
        maxDate: this.props.maxDate,
        locale: this.props.locale,
        startMode: this.props.startMode,
        fixedMode: this.props.fixedMode,
        floating: this.props.floating,
        closeOnClickOutside: this.props.closeOnClickOutside
      });
    }
  },

  render: function render() {
    var inputProps = _lodashOmit2['default'](this.props, Object.keys(propTypes));
    var _props = this.props;
    var showInputButton = _props.showInputButton;
    var active = _props.showing;
    var iconClassName = _props.iconClassName;
    var showOnInputClick = _props.showOnInputClick;
    var onClear = _props.onClear;
    var iconClearClassName = _props.iconClearClassName;
    var className = _props.className;
    var style = _props.style;

    var inputButton = _react2['default'].createElement(
      'div',
      { className: _classnames2['default']('input-button', { active: active }), onClick: this.toggleDatePicker },
      _react2['default'].createElement('i', { className: iconClassName })
    );

    var clearButton = _react2['default'].createElement(
      'div',
      { className: 'clear-button', onClick: this.onClear },
      _react2['default'].createElement('i', { className: iconClearClassName })
    );

    var onInputClick = showOnInputClick ? this.show : undefined;
    return _react2['default'].createElement(
      'div',
      {
        className: _classnames2['default']('react-datepicker-component', className),
        style: style,
        ref: 'datePickerInput'
      },
      _react2['default'].createElement(
        'div',
        { className: 'react-datepicker-input' },
        _react2['default'].createElement('input', _extends({
          valueLink: { value: this.state.dateString, requestChange: this.onChangeInput },
          onClick: onInputClick,
          onKeyUp: this.hideOnEnterKey
        }, inputProps)),
        _react2['default'].createElement(
          'div',
          { className: 'button-wrapper' },
          onClear && clearButton,
          showInputButton && inputButton
        )
      ),
      this.getDatePicker()
    );
  },

  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
    var _getValueLink = this.getValueLink(nextProps);

    var value = _getValueLink.value;

    if (value !== INVALID && value !== this.getValueLink().value) {
      if (value) {
        var date = typeof value === 'string' ? this.parsePropDateString(value, nextProps) : _moment2['default'](value);
        this.setState({
          date: date,
          dateString: date.isValid() ? this.formatDisplayedDate(date, nextProps) : this.state.dateString
        });
      } else {
        this.setState({
          date: undefined,
          dateString: ''
        });
      }
    }
  },

  componentWillUnmount: function componentWillUnmount() {
    if (this.props.closeOnClickOutside) {
      this.removeOnClickListener();
    }
  }

});

exports['default'] = DatePickerInput;
module.exports = exports['default'];


text:
/*
 * reconcilliation.c
 *
 *  Created on: 31-Mar-2010
 *      Author: benedictpaten
 */
#include <assert.h>

#include "cactus.h"
#include "commonC.h"

Event *labelAndReturnEvent(struct BinaryTree *blockTree, Event *event) {
	assert(event != NULL);
	blockTree->label = cactusMisc_nameToString(event_getName(event));
	return event;
}

Event *reconcile(struct BinaryTree *blockTree, EventTree *eventTree,
		Event *(*getEventFromLeaf)(struct BinaryTree *binaryTree, void *extraArg), void *extraArg) {
	if(blockTree->internal) { //internal node
		Event *leftChild = reconcile(blockTree->left, eventTree, getEventFromLeaf, extraArg);
		Event *rightChild = reconcile(blockTree->right, eventTree, getEventFromLeaf, extraArg);
		if(leftChild != NULL) {
			if(rightChild != NULL) {
				Event *commonAncestor = eventTree_getCommonAncestor(leftChild, rightChild);
				assert(commonAncestor != eventTree_getRootEvent(eventTree));
				if(commonAncestor == leftChild || commonAncestor == rightChild) {
					Event *parentEvent = event_getParent(commonAncestor);
					if(event_getChildNumber(parentEvent) != 1 || parentEvent == eventTree_getRootEvent(eventTree)) {
						//we need to invent a new event before the parent speciation or root of tree
						Event *newEvent = event_construct4(NULL, 0.01, parentEvent, commonAncestor, eventTree);
						return labelAndReturnEvent(blockTree, newEvent);
					}
					else { //there already exists a valid unary event..
						return labelAndReturnEvent(blockTree, parentEvent);
					}
				}
				else { //speciation case
					return labelAndReturnEvent(blockTree, commonAncestor);
				}
			}
			else {
				return leftChild;
			}
		}
		else {
			return rightChild;
		}
	}
	else { //leaf case
		Event *childEvent = getEventFromLeaf(blockTree, extraArg);
		return childEvent;
	}
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
AtomicNumber (Hazelcast API - 2.5)
</TITLE>

<META NAME="date" CONTENT="2013-01-15">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">

      Overview
      Package
    Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.hazelcast.core

Interface AtomicNumber

All Superinterfaces:
Instance

public interface AtomicNumber
extends Instance

AtomicNumber is a backed-up distributed implementation of
 java.util.concurrent.atomic.AtomicLong.

Nested Class Summary

Nested classes/interfaces inherited from interface com.hazelcast.core.Instance

Instance.InstanceType

Method Summary

 long
addAndGet(long delta)

          Atomically adds the given value to the current value.

 boolean
compareAndSet(long expect,
              long update)

          Atomically sets the value to the given updated value
 only if the current value == the expected value.

 long
decrementAndGet()

          Atomically decrements the current value by one.

 long
get()

          Gets the current value.

 long
getAndAdd(long delta)

          Atomically adds the given value to the current value.

 long
getAndSet(long newValue)

          Atomically sets the given value and returns the old value.

 LocalAtomicNumberStats
getLocalAtomicNumberStats()

 String
getName()

          Returns the name of this IAtomicLong instance.

 long
incrementAndGet()

          Atomically increments the current value by one.

 void
lazySet(long newValue)

          Deprecated.

 void
set(long newValue)

          Atomically sets the given value.

 boolean
weakCompareAndSet(long expect,
                  long update)

          Deprecated.

Methods inherited from interface com.hazelcast.core.Instance

destroy, getId, getInstanceType

Method Detail

getName

String getName()

Returns the name of this IAtomicLong instance.

Returns:
name of this instance

addAndGet

long addAndGet(long delta)

Atomically adds the given value to the current value.

Parameters:
delta - the value to add

Returns:
the updated value

compareAndSet

boolean compareAndSet(long expect,
                      long update)

Atomically sets the value to the given updated value
 only if the current value == the expected value.

Parameters:
expect - the expected value
update - the new value

Returns:
true if successful; or false if the actual value
         was not equal to the expected value.

decrementAndGet

long decrementAndGet()

Atomically decrements the current value by one.

Returns:
the updated value

get

long get()

Gets the current value.

Returns:
the current value

getAndAdd

long getAndAdd(long delta)

Atomically adds the given value to the current value.

Parameters:
delta - the value to add

Returns:
the old value before the add

getAndSet

long getAndSet(long newValue)

Atomically sets the given value and returns the old value.

Parameters:
newValue - the new value

Returns:
the old value

incrementAndGet

long incrementAndGet()

Atomically increments the current value by one.

Returns:
the updated value

set

void set(long newValue)

Atomically sets the given value.

Parameters:
newValue - the new value

weakCompareAndSet

@Deprecated
boolean weakCompareAndSet(long expect,
                                     long update)

Deprecated.

Not implemented. Use compareAndSet().

lazySet

@Deprecated
void lazySet(long newValue)

Deprecated.

getLocalAtomicNumberStats

LocalAtomicNumberStats getLocalAtomicNumberStats()

      Overview
      Package
    Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

Copyright © 2008-2012 Hazelcast, Inc. All Rights Reserved.


text:
// database.h

#pragma once

#include "cmdline.h"

namespace mongo {

    class ClientCursor;
    struct ByLocKey;
    typedef map<ByLocKey, ClientCursor*> CCByLoc;

    /**
     * Database represents a database database
     * Each database database has its own set of files -- dbname.ns, dbname.0, dbname.1, ...
     * NOT memory mapped
    */
    class Database {
    public:
        static bool _openAllFiles;

        Database(const char *nm, /*out*/ bool& newDb, const string& _path = dbpath);
    private:
        ~Database();
    public:
        /* you must use this to close - there is essential code in this method that is not in the ~Database destructor.
           thus the destructor is private.  this could be cleaned up one day...
        */
        static void closeDatabase( const char *db, const string& path );

        void openAllFiles();

        void finishInit();

        /**
         * tries to make sure that this hasn't been deleted
         */
        bool isOk() const { return magic == 781231; }

        bool isEmpty() { return ! namespaceIndex.allocated(); }

        /**
         * total file size of Database in bytes
         */
        long long fileSize() const;

        int numFiles() const { return (int)files.size(); }

        /**
         * returns file valid for file number n
         */
        boost::filesystem::path fileName( int n ) const;

        bool exists(int n) const { return boost::filesystem::exists( fileName( n ) ); }

        /**
         * return file n.  if it doesn't exist, create it
         */
        MongoDataFile* getFile( int n, int sizeNeeded = 0, bool preallocateOnly = false );

        MongoDataFile* addAFile( int sizeNeeded, bool preallocateNextFile );

        /**
         * makes sure we have an extra file at the end that is empty
         * safe to call this multiple times - the implementation will only preallocate one file
         */
        void preallocateAFile() { getFile( numFiles() , 0, true ); }

        MongoDataFile* suitableFile( int sizeNeeded, bool preallocate );

        Extent* allocExtent( const char *ns, int size, bool capped );

        MongoDataFile* newestFile();

        /**
         * @return true if success.  false if bad level or error creating profile ns
         */
        bool setProfilingLevel( int newLevel , string& errmsg );

        void flushFiles( bool sync ) const;

        /**
         * @return true if ns is part of the database
         *         ns=foo.bar, db=foo returns true
         */
        bool ownsNS( const string& ns ) const {
            if ( ! startsWith( ns , name ) )
                return false;
            return ns[name.size()] == '.';
        }

        static bool validDBName( const string& ns );

    public: // this should be private later

        vector<MongoDataFile*> files;
        const string name; // "alleyinsider"
        const string path;
        NamespaceIndex namespaceIndex;
        int profile; // 0=off.
        const string profileName; // "alleyinsider.system.profile"
        CCByLoc ccByLoc;
        int magic; // used for making sure the object is still loaded in memory
    };

} // namespace mongo


text:
package com.github.dannil.scbjavaclient.client.financialmarkets.balanceofpayments.economicindicators;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import com.github.dannil.scbjavaclient.client.AbstractClient;
import com.github.dannil.scbjavaclient.communication.URLEndpoint;
import com.github.dannil.scbjavaclient.constants.APIConstants;
import com.github.dannil.scbjavaclient.model.ResponseModel;

/**
 *
Client which handles financial markets balance of payments economic indicators data
 * fetching.

 *
 * @since 0.4.0
 */
public class FinancialMarketsBalanceOfPaymentsEconomicIndicatorsClient extends AbstractClient {

    /**
     *
Default constructor.

     */
    public FinancialMarketsBalanceOfPaymentsEconomicIndicatorsClient() {
        super();
    }

    /**
     *
Overloaded constructor.

     *
     * @param locale
     *            the Locale for this client
     */
    public FinancialMarketsBalanceOfPaymentsEconomicIndicatorsClient(Locale locale) {
        super(locale);
    }

    /**
     *
Fetch all balance of payments net data.

     *
     * @return the data wrapped in a list of
     *         {@link com.github.dannil.scbjavaclient.model.ResponseModel ResponseModel}
     *         objects
     *
     * @see #getBalanceOfPaymentsNet(Collection, Collection)
     */
    public List<ResponseModel> getBalanceOfPaymentsNet() {
        return getBalanceOfPaymentsNet(null, null);
    }

    /**
     *
Fetch all balance of payments net data which match the input constraints.

     *
     * @param indicators
     *            the indicators
     * @param quarters
     *            the quarters
     * @return the data wrapped in a list of
     *         {@link com.github.dannil.scbjavaclient.model.ResponseModel ResponseModel}
     *         objects
     */
    public List<ResponseModel> getBalanceOfPaymentsNet(Collection<String> indicators, Collection<String> quarters) {
        Map<String, Collection<?>> mappings = new HashMap<>();
        mappings.put(APIConstants.ECONOMICINDICATOR_CODE, indicators);
        mappings.put(APIConstants.TIME_CODE, quarters);

        return getResponseModels("SnabbStatFM0001", mappings);
    }

    @Override
    public URLEndpoint getUrl() {
        return getRootUrl().append("FM/FM0001/FM0001S/");
    }

}


text:
namespace chromeos {

HIDDetectionScreenHandler::HIDDetectionScreenHandler()
    : BaseScreenHandler(kScreenId) {}

HIDDetectionScreenHandler::~HIDDetectionScreenHandler() = default;

void HIDDetectionScreenHandler::Show() {
  ShowInWebUI();
}

void HIDDetectionScreenHandler::SetKeyboardState(const std::string& value) {
  keyboard_state_ = value;
  CallExternalAPI("setKeyboardState", value);
}

void HIDDetectionScreenHandler::SetMouseState(const std::string& value) {
  mouse_state_ = value;
  CallExternalAPI("setMouseState", value);
}

void HIDDetectionScreenHandler::SetTouchscreenDetectedState(bool value) {
  CallExternalAPI("setTouchscreenDetectedState", value);
}

void HIDDetectionScreenHandler::SetKeyboardPinCode(const std::string& value) {
  keyboard_pin_code_ = value;
  CallExternalAPI("setKeyboardPinCode", value);
}

void HIDDetectionScreenHandler::SetPinDialogVisible(bool value) {
  num_keys_entered_expected_ = value;
  CallExternalAPI("setPinDialogVisible", value);
}

void HIDDetectionScreenHandler::SetNumKeysEnteredPinCode(int value) {
  num_keys_entered_pin_code_ = value;
  CallExternalAPI("setNumKeysEnteredPinCode", value);
}

void HIDDetectionScreenHandler::SetPointingDeviceName(
    const std::string& value) {
  mouse_device_name_ = value;
  CallExternalAPI("setPointingDeviceName", value);
}

void HIDDetectionScreenHandler::SetKeyboardDeviceName(
    const std::string& value) {
  keyboard_device_name_ = value;
  CallExternalAPI("setKeyboardDeviceName", value);
}

void HIDDetectionScreenHandler::SetContinueButtonEnabled(bool value) {
  continue_button_enabled_ = value;
  CallExternalAPI("setContinueButtonEnabled", value);
}

void HIDDetectionScreenHandler::DeclareLocalizedValues(
    ::login::LocalizedValuesBuilder* builder) {
  builder->Add("hidDetectionContinue", IDS_HID_DETECTION_CONTINUE_BUTTON);
  builder->Add("hidDetectionInvitation", IDS_HID_DETECTION_INVITATION_TEXT);
  builder->Add("hidDetectionPrerequisites",
      IDS_HID_DETECTION_PRECONDITION_TEXT);
  builder->Add("hidDetectionPrerequisitesTouchscreen",
               IDS_HID_DETECTION_PRECONDITION_TOUCHSCREEN_TEXT);
  builder->Add("hidDetectionMouseSearching", IDS_HID_DETECTION_SEARCHING_MOUSE);
  builder->Add("hidDetectionKeyboardSearching",
      IDS_HID_DETECTION_SEARCHING_KEYBOARD);
  builder->Add("hidDetectionUSBMouseConnected",
      IDS_HID_DETECTION_CONNECTED_USB_MOUSE);
  builder->Add("hidDetectionPointingDeviceConnected",
      IDS_HID_DETECTION_CONNECTED_POINTING_DEVICE);
  builder->Add("hidDetectionKeyboardPairing",
               IDS_HID_DETECTION_PAIRING_BLUETOOTH_KEYBOARD);
  builder->Add("hidDetectionUSBKeyboardConnected",
      IDS_HID_DETECTION_CONNECTED_USB_KEYBOARD);
  builder->Add("hidDetectionBTMousePaired",
      IDS_HID_DETECTION_PAIRED_BLUETOOTH_MOUSE);
  builder->Add("hidDetectionBTEnterKey", IDS_HID_DETECTION_BLUETOOTH_ENTER_KEY);
  builder->Add("hidDetectionPinDialogTitle",
               IDS_HID_DETECTION_PAIRING_BLUETOOTH_KEYBOARD_PIN_DIALOG_TITLE);
  builder->Add("hidDetectionBluetoothPairingCode",
               IDS_HID_DETECTION_BLUETOOTH_PAIRING_CODE);
  builder->Add("hidDetectionBluetoothPairingCodeExplanation",
               IDS_HID_DETECTION_BLUETOOTH_PAIRING_CODE_EXPLANATION);
  builder->Add("hidDetectionBluetoothKeyboardPaired",
               IDS_HID_DETECTION_PAIRED_BLUETOOTH_KEYBOARD);
  builder->Add("oobeModalDialogClose", IDS_CHROMEOS_OOBE_CLOSE_DIALOG);
  builder->Add("hidDetectionTouchscreenDetected",
               IDS_HID_DETECTION_DETECTED_TOUCHSCREEN);
  builder->Add("bluetoothPairingEnterKeys", IDS_BLUETOOTH_PAIRING_ENTER_KEYS);
  builder->Add("bluetoothEnterKey", IDS_BLUETOOTH_PAIRING_ENTER_KEY);
  builder->Add("bluetoothPairNewDevice",
               IDS_BLUETOOTH_PAIRING_PAIR_NEW_DEVICES);
  builder->Add("bluetoothPair", IDS_BLUETOOTH_PAIRING_PAIR);
}

void HIDDetectionScreenHandler::GetAdditionalParameters(
    base::Value::Dict* dict) {
  dict->Set("enableOobeHidDetectionRevamp",
            base::FeatureList::IsEnabled(features::kOobeHidDetectionRevamp));
  BaseScreenHandler::GetAdditionalParameters(dict);
}

}  // namespace chromeos


text:
from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('music', '0001_initial'),
    ]

    operations = [
        migrations.AddField(
            model_name='song',
            name='is_favourite',
            field=models.BooleanField(default=False),
        ),
    ]