text:
package org.ergoplatform

import java.util

import com.google.common.primitives.Ints
import org.ergoplatform.ErgoAddressEncoder.NetworkPrefix
import scorex.crypto.hash.{Digest32, Blake2b256}
import scorex.util.encode.Base58
import sigmastate.Values._
import sigmastate._
import sigmastate.basics.DLogProtocol.{ProveDlogProp, ProveDlog}
import sigmastate.lang.exceptions.SigmaException
import sigmastate.serialization._
import sigmastate.utxo.{DeserializeContext, Slice}
import special.collection.Coll

import scala.util.Try

/**
  * An address is a short string corresponding to some script used to protect a box. Unlike (string-encoded) binary
  * representation of a script, an address has some useful characteristics:
  *
  * - Integrity of an address could be checked., as it is incorporating a checksum.
  * - A prefix of address is showing network and an address type.
  * - An address is using an encoding (namely, Base58) which is avoiding similarly l0Oking characters, friendly to
  * double-clicking and line-breaking in emails.
  *
  *
  *
  * An address is encoding network type, address type, checksum, and enough information to watch for a particular scripts.
  *
  * Possible network types are:
  * Mainnet - 0x00
  * Testnet - 0x10
  *
  * Address types are, semantics is described below:
  * 0x01 - Pay-to-PublicKey(P2PK) address
  * 0x02 - Pay-to-Script-Hash(P2SH)
  * 0x03 - Pay-to-Script(P2S)
  *
  * For an address type, we form content bytes as follows:
  *
  * P2PK - serialized (compressed) public key
  * P2SH - first 192 bits of the Blake2b256 hash of serialized script bytes
  * P2S  - serialized script
  *
  * Address examples for testnet:
  *
  * 3   - P2PK (3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN)
  * ?   - P2SH (rbcrmKEYduUvADj9Ts3dSVSG27h54pgrq5fPuwB)
  * ?   - P2S (Ms7smJwLGbUAjuWQ)
  *
  * for mainnet:
  *
  * 9  - P2PK (9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA)
  * ?  - P2SH (8UApt8czfFVuTgQmMwtsRBZ4nfWquNiSwCWUjMg)
  * ?  - P2S (4MQyML64GnzMxZgm, BxKBaHkvrTvLZrDcZjcsxsF7aSsrN73ijeFZXtbj4CXZHHcvBtqSxQ)
  *
  *
  * Prefix byte = network type + address type
  *
  * checksum = blake2b256(prefix byte ++ content bytes)
  *
  * address = prefix byte ++ content bytes ++ checksum
  *
  */
sealed trait ErgoAddress {
  /** Address type code used to differentiate between pay-to-public-key, pay-to-script,
    * pay-to-script-hash addresses.
    *
    * NOTE: Network type code is defined by [[ErgoAddressEncoder]] attached to each ErgoAddress
    * instance and it is not included in this value.
    *
    * @see [[P2PKAddress]], [[Pay2SAddress]], [[Pay2SHAddress]]
    */
  val addressTypePrefix: Byte

  /** Serialized bytes of the address content (depending on the address type).
    * Doesn't include network type and address type prefix byte.
    * @see [[P2PKAddress]], [[Pay2SAddress]], [[Pay2SHAddress]]
    */
  val contentBytes: Array[Byte]

  /** ErgoTree which corresponds to the address (depending on the address type).
    * @see [[P2PKAddress]], [[Pay2SAddress]], [[Pay2SHAddress]]
    */
  val script: ErgoTree

  /** Network type code to be used in address encoding. */
  def networkPrefix: NetworkPrefix
}

/** Implementation of pay-to-public-key [[ErgoAddress]]. */
class P2PKAddress(val pubkey: ProveDlog,
                  val pubkeyBytes: Array[Byte])
                 (implicit val encoder: ErgoAddressEncoder) extends ErgoAddress {

  override val addressTypePrefix: Byte = P2PKAddress.addressTypePrefix

  override val contentBytes: Array[Byte] = pubkeyBytes

  override val script: ErgoTree = {
    // NOTE: we don't segregate constants because the whole tree is single constant
    // and we want different addresses of this type to have different `script` values
    ErgoTree(ErgoTree.DefaultHeader, ErgoTree.EmptyConstants, SigmaPropConstant(pubkey))
  }

  override def networkPrefix: NetworkPrefix = encoder.networkPrefix

  override def equals(obj: Any): Boolean = obj match {
    case p2pk: P2PKAddress => util.Arrays.equals(pubkeyBytes, p2pk.pubkeyBytes)
    case _ => false
  }

  override def hashCode(): Int = Ints.fromByteArray(pubkeyBytes)

  override def toString: String = encoder.toString(this)
}

object P2PKAddress {
  /** Value added to the prefix byte in the serialized bytes of an encoded P2PK address.
    * @see [[ErgoAddressEncoder.toString]]
    */
  val addressTypePrefix: Byte = 1: Byte

  /** Constructs [[P2PKAddress]] instance using the public key of the given [[ProveDlog]]. */
  def apply(pubkey: ProveDlog)(implicit encoder: ErgoAddressEncoder): P2PKAddress = {
    val bs = GroupElementSerializer.toBytes(pubkey.h)
    new P2PKAddress(pubkey, bs)
  }
}

/** Implementation of pay-to-script-hash [[ErgoAddress]]. */
class Pay2SHAddress(val scriptHash: Array[Byte])(implicit val encoder: ErgoAddressEncoder) extends ErgoAddress {
  override val addressTypePrefix: Byte = Pay2SHAddress.addressTypePrefix

  override val contentBytes: Array[Byte] = scriptHash

  override def networkPrefix: NetworkPrefix = encoder.networkPrefix

  import Pay2SHAddress._

  /** The proposition which checks that `contextVar(scriptId)` has original script
    * (whose hash equals to this [[scriptHash]]) which evaluates to true.
    *
    * Assumes the context variable is accessed as `getVar[Coll[Byte]](1).get`
    * and contains serialized original script bytes.
    *
    * NOTE: This script is not stored in [[contentBytes]] of the address.
    * So the address doesn't depend on this script which means this specific script can be
    * changed without breaking the addresses.
    *
    * NOTE: The ErgoTree is created without segregation of the constants.
    *
    * NOTE: that P2SH address is using 192-bits hash, unlike the "P2SH - 160 bits" example
    * (and well-known P2SH addresses in Bitcoin)
    *
    * @see ErgoLikeInterpreterSpecification the "P2SH - 160 bits" test
    */
  override val script = {
    val hashEquals = EQ(
      Slice(CalcBlake2b256(GetVarByteArray(scriptId).get), IntConstant(0), IntConstant(24)),
      scriptHash
    )
    val scriptIsCorrect = DeserializeContext(scriptId, SSigmaProp)
    ErgoTree.withoutSegregation(SigmaAnd(hashEquals.toSigmaProp, scriptIsCorrect))
  }

  override def equals(obj: Any): Boolean = obj match {
    case p2sh: Pay2SHAddress => util.Arrays.equals(scriptHash, p2sh.scriptHash)
    case _ => false
  }

  override def hashCode(): Int = Ints.fromByteArray(scriptHash)

  override def toString: String = encoder.toString(this)
}

object Pay2SHAddress {
  /** An id of the context variable used in pay-to-script-hash address script.
    * @see [[Pay2SHAddress.script]]
    */
  val scriptId = 1: Byte

  /** Value added to the prefix byte in the serialized bytes of an encoded P2SH address.
    * @see [[ErgoAddressEncoder.toString]]
    */
  val addressTypePrefix: Byte = 2: Byte

  /** Create Pay-to-script-hash address with the given underlying script (ErgoTree).
    *
    * The tree is first transformed to proposition, substituting the constants if necessary
    * and then the other constructor is called.
    *
    * @param  script  ErgoTree representation of guarding script
    * @param  encoder address encoder which is used to encode address bytes as String
    */
  def apply(script: ErgoTree)(implicit encoder: ErgoAddressEncoder): Pay2SHAddress = {
    val prop = script.toProposition(replaceConstants = script.isConstantSegregation)
    apply(prop)
  }

  /** Create Pay-to-script-hash address with the given underlying proposition (SigmaPropValue).
    *
    * The proposition is serialized to bytes, then hashed (Blake2b256) and then 24
    * bytes of the hash are taken as contentBytes of the address.
    *
    * @param  prop    Value representation of guarding script (aka proposition)
    * @param  encoder address encoder which is used to encode address bytes as String
    */
  def apply(prop: SigmaPropValue)(implicit encoder: ErgoAddressEncoder): Pay2SHAddress = {
    val sb = ValueSerializer.serialize(prop)
    val sbh = ErgoAddressEncoder.hash192(sb)
    new Pay2SHAddress(sbh)
  }
}

/** Implementation of pay-to-script [[ErgoAddress]]. */
class Pay2SAddress(override val script: ErgoTree,
                   val scriptBytes: Array[Byte])
                  (implicit val encoder: ErgoAddressEncoder) extends ErgoAddress {
  override val addressTypePrefix: Byte = Pay2SAddress.addressTypePrefix

  override val contentBytes: Array[Byte] = scriptBytes

  override def networkPrefix: NetworkPrefix = encoder.networkPrefix

  override def equals(obj: Any): Boolean = obj match {
    case p2s: Pay2SAddress => util.Arrays.equals(scriptBytes, p2s.scriptBytes)
    case _ => false
  }

  override def hashCode(): Int = Ints.fromByteArray(scriptBytes)

  override def toString: String = encoder.toString(this)
}

object Pay2SAddress {
  /** Value added to the prefix byte in the serialized bytes of an encoded P2S address.
    * @see [[ErgoAddressEncoder.toString()]]
    */
  val addressTypePrefix: Byte = 3: Byte

  /** Create Pay-to-script address with the given underlying script (ErgoTree).
    *
    * The tree is serialized to contentBytes using default ErgoTree serializer.
    *
    * @param  script  ErgoTree representation of guarding script
    * @param  encoder address encoder which is used to encode address bytes as String
    */
  def apply(script: ErgoTree)(implicit encoder: ErgoAddressEncoder): Pay2SAddress = {
    val sb = ErgoTreeSerializer.DefaultSerializer.serializeErgoTree(script)
    new Pay2SAddress(script, sb)
  }
}

/** Network-aware encoder for ErgoAddress <-> Base58String conversions.
  * @param networkPrefix network prefix value to be used in address encoding.
  */
case class ErgoAddressEncoder(networkPrefix: NetworkPrefix) {

  import ErgoAddressEncoder._

  /** This value is be used implicitly in the methods below. */
  implicit private def ergoAddressEncoder: ErgoAddressEncoder = this

  /** Converts the given [[ErgoAddress]] to Base58 string. */
  def toString(address: ErgoAddress): String = {
    val withNetworkByte = (networkPrefix + address.addressTypePrefix).toByte +: address.contentBytes

    val checksum = hash256(withNetworkByte).take(ChecksumLength)
    Base58.encode(withNetworkByte ++ checksum)
  }

  /** Returns true if the given `addrHeadByte` is a header byte of a testnet address, false otherwise. */
  def isTestnetAddress(addrHeadByte: Byte): Boolean = addrHeadByte > TestnetNetworkPrefix

  /** Returns true if the given `addrHeadByte` is a header byte of a mainnet address, false otherwise. */
  def isMainnetAddress(addrHeadByte: Byte): Boolean = addrHeadByte < TestnetNetworkPrefix

  /** Converts the given Base58 string to [[ErgoAddress]] or an error packed in Try. */
  def fromString(addrBase58Str: String): Try[ErgoAddress] = Base58.decode(addrBase58Str).flatMap { bytes =>
    Try {
      val headByte = bytes.head
      networkPrefix match {
        case TestnetNetworkPrefix => require(isTestnetAddress(headByte), "Trying to decode mainnet address in testnet")
        case MainnetNetworkPrefix => require(isMainnetAddress(headByte), "Trying to decode testnet address in mainnet")
      }
      val addressType = (headByte - networkPrefix).toByte
      val (withoutChecksum, checksum) = bytes.splitAt(bytes.length - ChecksumLength)

      if (!util.Arrays.equals(hash256(withoutChecksum).take(ChecksumLength), checksum)) {
        throw new Exception(s"Checksum check fails for $addrBase58Str")
      }

      val contentBytes = withoutChecksum.tail

      addressType match {
        case P2PKAddress.addressTypePrefix =>
          val r = SigmaSerializer.startReader(contentBytes)
          val p = GroupElementSerializer.parse(r)
          new P2PKAddress(ProveDlog(p), contentBytes)
        case Pay2SHAddress.addressTypePrefix =>
          if (contentBytes.length != 24) { //192-bits hash used
            throw new Exception(s"Improper content in P2SH script: $addrBase58Str")
          }
          new Pay2SHAddress(contentBytes)
        case Pay2SAddress.addressTypePrefix =>
          val tree = ErgoTreeSerializer.DefaultSerializer.deserializeErgoTree(contentBytes)
          new Pay2SAddress(tree, contentBytes)
        case _ =>
          throw new Exception(s"Unsupported address type: $addressType")
      }
    }
  }

  /** Pattern recognizer of [[Pay2SHAddress.script]] propositions.
    * If matched extracts the corresponding hash bytes as `Coll[Byte]` value.
    */
  object IsPay2SHAddress {
    def unapply(exp: SigmaPropValue): Option[Coll[Byte]] = exp match {
      case SigmaAnd(Seq(
            BoolToSigmaProp(
              EQ(
                Slice(_: CalcHash, ConstantNode(0, SInt), ConstantNode(24, SInt)),
                ByteArrayConstant(scriptHash))),
            DeserializeContext(Pay2SHAddress.scriptId, SSigmaProp))) => Some(scriptHash)
      case _ => None
    }
  }

  /** Converts the given [[ErgoTree]] to the corresponding [[ErgoAddress]].
    * It is inverse of [[ErgoAddress.script]] such that `fromProposition(addr.script) == addr`
    *
    * @return Failure(ex) if the `proposition` cannot be converted to any type of address.
    */
  def fromProposition(proposition: ErgoTree): Try[ErgoAddress] = Try {
    proposition.root match {
      case Right(SigmaPropConstant(ProveDlogProp(d))) => P2PKAddress(d)
      case Right(IsPay2SHAddress(scriptHash)) => new Pay2SHAddress(scriptHash.toArray)
      case Right(b: Value[SSigmaProp.type]@unchecked) if b.tpe == SSigmaProp => Pay2SAddress(proposition)
      case Left(unparsedErgoTree) =>
        throw new SigmaException(s"Cannot create ErgoAddress form unparsed ergo tree: $unparsedErgoTree")
      case _ =>
        throw new RuntimeException(s"Cannot create ErgoAddress form proposition: $proposition")
    }
  }
}

object ErgoAddressEncoder {
  /** Type of the network prefix value. */
  type NetworkPrefix = Byte

  /** Value of the prefix byte used to encode Mainnet ErgoAddress. */
  val MainnetNetworkPrefix: NetworkPrefix = 0.toByte

  /** Value of the prefix byte used to encode Testnet ErgoAddress. */
  val TestnetNetworkPrefix: NetworkPrefix = 16.toByte

  /** Length of the checksum section of encoded ergo address bytes. */
  val ChecksumLength = 4

  /** Helper method to hash the given array using Blake2b256. */
  def hash256(input: Array[Byte]): Digest32 = Blake2b256(input)

  /** Helper method to hash the given array using Blake2b256 and take first 192 bit (24 bytes). */
  def hash192(input: Array[Byte]): Array[Byte] = hash256(input).take(24)
}


text:
package org.karlsland.m3g;

public class Background extends Object3D {

    public final static int BORDER = 32;
    public final static int REPEAT = 33;

    native private void    jni_initialize          ();
    native private void    jni_finalize            ();
    native private int     jni_getColor            ();
    native private int     jni_getCropHeight       ();
    native private int     jni_getCropWidth        ();
    native private int     jni_getCropX            ();
    native private int     jni_getCropY            ();
    native private Image2D jni_getImage            ();
    native private int     jni_getImageModeX       ();
    native private int     jni_getImageModeY       ();
    native private boolean jni_isColorClearEnabled ();
    native private boolean jni_isDepthClearEnabled ();
    native private void    jni_setColor            (int ARGB);
    native private void    jni_setColorClearEnable (boolean enable);
    native private void    jni_setCrop             (int cropX, int cropY, int width, int height);
    native private void    jni_setDepthClearEnable (boolean enable);
    native private void    jni_setImage            (Image2D image);
    native private void    jni_setImageMode        (int modeX, int modeY);
    native private String  jni_print               ();

    private Image2D image;

    public Background () {
       this.image = null;
    	jni_initialize ();
   }

    @Override
    protected void finalize () {
        jni_finalize ();
    }

    public int getColor () {
        return jni_getColor ();
    }

    public int getCropHeight () {
        return jni_getCropHeight ();
    }

    public int getCropWidth () {
        return jni_getCropWidth ();
    }

    public int getCropX () {
        return jni_getCropX ();
    }

    public int getCropY () {
        return jni_getCropY ();
    }

    public Image2D getImage () {
        return jni_getImage ();
    }

    public int getImageModeX () {
        return jni_getImageModeX ();
    }

    public int getImageModeY () {
        return jni_getImageModeY ();
    }

    public boolean isColorClearEnabled () {
        return jni_isColorClearEnabled ();
    }

    public boolean isDepthClearEnabled () {
        return jni_isDepthClearEnabled ();
    }

    public void setColor (int ARGB) {
        jni_setColor (ARGB);
    }

    public void setColorClearEnable (boolean enable) {
        jni_setColorClearEnable (enable);
    }

    public void setCrop (int cropX, int cropY, int width, int height) {
        jni_setCrop (cropX, cropY, width, height);
    }

    public void setDepthClearEnable (boolean enable) {
        jni_setDepthClearEnable (enable);
    }

    public void setImage (Image2D image) {
        jni_setImage (image);
        this.image = image;
    }

    public void setImageMode (int modeX, int modeY) {
        jni_setImageMode (modeX, modeY);
    }

    @Override
    public String toString () {
        return jni_print ();
    }

}

redpajama_set_name: RedPajamaGithub


text:
using System;

namespace Backend.Fx.Exceptions
{
    public class UnauthorizedException : ClientException
    {
        public UnauthorizedException()
            : base("Unauthorized")
        {
        }

        /// <inheritdoc />
        public UnauthorizedException(string message)
            : base(message)
        {
        }

        /// <inheritdoc />
        public UnauthorizedException(string message, Exception innerException)
            : base(message, innerException)
        {
        }
    }
}


text:
package seedu.addressbook.data.person;

public class PostalCode {
	public static final String POSTALCODE_VALIDATION_REGEX = "\\d+";
	public String value;

	public PostalCode() {

	}

	public PostalCode(String postalCode) {
		this.value = postalCode;
	}

	public boolean isValidPostalCode() {
		return value.matches(POSTALCODE_VALIDATION_REGEX) || value == "";
	}
}


text:
import stopwords from './stopwords/english';

// eslint-disable-next-line import/prefer-default-export
export const Stopwords = {
  run: input => input.filter(word => stopwords.indexOf(word) === -1),
};


text:
Application Shortcuts
==============

Demonstrates how to use the `UIApplicationShortcutItem` class to provide quick access to parts of your application directly from the device's home screen. The sample shows two static shortcuts (defined in the app's Info.plist), and two dynamic shortcuts (defined in code with the `UIMutableApplicationShortcutItem` class). The dynamic shortcuts can be edited to change the title, subtitle and icon.

Build Requirements
------------------

Building this sample requires Xcode 7.0 and iOS 9.0 SDK

Refs
----
[Original sample](https://developer.apple.com/library/prerelease/ios/samplecode/ApplicationShortcuts/Introduction/Intro.html#//apple_ref/doc/uid/TP40016545)

Target
------
This sample runnable on iPhone/iPad with 3D Touch support

Author
------
Copyright (C) 2015 Apple Inc. All rights reserved.

Ported to Xamarin.iOS by Rustam Zaitov


text:
package com.nearsoft.incubator.controller;

import com.nearsoft.incubator.model.Schedule;
import com.nearsoft.incubator.service.ScheduleService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.text.SimpleDateFormat;
import java.util.Date;

import static org.easymock.EasyMock.*;
import static org.hamcrest.Matchers.isEmptyString;
import static org.hamcrest.Matchers.not;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

/**
 * Created by edgar on 1/07/14.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations = {
        "classpath:spring/mvc-beans.xml",
        "classpath:spring/controller-beans-test.xml"
})
public class ScheduleControllerTest {

    @Autowired
    private ScheduleService service;
    @Autowired
    private WebApplicationContext context;
    @Autowired
    private String departureAirportUrlParam;
    @Autowired
    private String arrivalAirportUrlParam;
    @Autowired
    private String departureDateUrlParam;
    @Autowired
    private String arrivalDateUrlParam;
    @Autowired
    private String dateFormat;
    private MockMvc mockMvc;

    @Before
    public void setUp(){
        mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
    }

    @Test
    public void testGetSchedule() throws Exception {
        Schedule schedule = new Schedule();
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        Date departureDate = format.parse(departureDateUrlParam);
        Date arrivalDate = format.parse(arrivalDateUrlParam);
        expect(service.getScheduleByRoute(eq(departureAirportUrlParam), eq(arrivalAirportUrlParam),
                eq(departureDate), eq(arrivalDate))).andReturn(schedule).once();
        replay(service);
        mockMvc.perform(get("/schedules")
                    .param("departureAirport", departureAirportUrlParam)
                    .param("arrivalAirport", arrivalAirportUrlParam)
                    .param("departureDate", departureDateUrlParam)
                    .param("arrivalDate", arrivalDateUrlParam)
                    .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().string(not(isEmptyString())));
        verify(service);
    }
}


text:
module Formtastic
  module Inputs
    class SelectInput

      def collection
        super.sort{|a, b| a[0].to_s.strip <=> b[0].to_s.strip}
      end

    end
  end
end


text:
package com.system.dormitory.dormitory_system_android.data;

import java.io.Serializable;
import java.util.Date;

public class BoardItem extends Item implements Serializable {
    public BoardItem() {
        super();
    }

    public BoardItem(String title, String content) {
        super(title, content);
    }

    public BoardItem(int roomNumber, String title, String content, int sno, String time) {
        super(roomNumber, title, content, sno, time);
    }
}


text:
/// <autosync enabled="true" />
/// <reference path="../gulpfile.js" />
/// <reference path="js/admin/theme.custom.js" />
/// <reference path="js/admin/theme.init.js" />
/// <reference path="js/admin/theme.js" />
/// <reference path="js/app.js" />
/// <reference path="js/controllers.js" />
/// <reference path="js/core/api.js" />
/// <reference path="js/core/csi.js" />
/// <reference path="js/core/project.js" />
/// <reference path="js/directives.js" />
/// <reference path="js/modernizr.js" />
/// <reference path="js/routes.js" />
/// <reference path="js/site.min.js" />
/// <reference path="js/spec.js" />
/// <reference path="js/sys/login.js" />
/// <reference path="js/sys/user.js" />
/// <reference path="js/theme.init.js" />
/// <reference path="lib/angular/angular.js" />
/// <reference path="lib/angular-animate/angular-animate.js" />
/// <reference path="lib/angular-bootstrap/ui-bootstrap-tpls.js" />
/// <reference path="lib/angular-cookies/angular-cookies.js" />
/// <reference path="lib/angular-daterangepicker/js/angular-daterangepicker.js" />
/// <reference path="lib/angularjs-toaster/toaster.js" />
/// <reference path="lib/angularlocalstorage/dist/angularLocalStorage.min.js" />
/// <reference path="lib/angular-resource/angular-resource.js" />
/// <reference path="lib/angular-route/angular-route.js" />
/// <reference path="lib/angular-swx-session-storage/release/swx-session-storage.min.js" />
/// <reference path="lib/angular-ui-ace/ui-ace.js" />
/// <reference path="lib/angular-ui-codemirror/ui-codemirror.js" />
/// <reference path="lib/angular-ui-layout/src/ui-layout.js" />
/// <reference path="lib/appear/jquery.appear.js" />
/// <reference path="lib/bootbox.js/bootbox.js" />
/// <reference path="lib/bootstrap/dist/js/bootstrap.js" />
/// <reference path="lib/bootstrap-datepicker/js/bootstrap-datepicker.js" />
/// <reference path="lib/bootstrap-daterangepicker/daterangepicker.js" />
/// <reference path="lib/bootstrap-multiselect/dist/js/bootstrap-multiselect.js" />
/// <reference path="lib/codemirror/lib/codemirror.js" />
/// <reference path="lib/jquery.fancytree/dist/jquery.fancytree-all.js" />
/// <reference path="lib/jquery.layout/dist/jquery.layout-latest.js" />
/// <reference path="lib/jquery/dist/jquery.js" />
/// <reference path="lib/jquery-ui/jquery-ui.js" />
/// <reference path="lib/jquery-validation/dist/jquery.validate.js" />
/// <reference path="lib/jquery-validation-unobtrusive/jquery.validate.unobtrusive.js" />
/// <reference path="lib/lodash/lodash.js" />
/// <reference path="lib/magnific-popup/dist/jquery.magnific-popup.js" />
/// <reference path="lib/moment/moment.js" />
/// <reference path="lib/nanoscroller/bin/javascripts/jquery.nanoscroller.js" />
/// <reference path="lib/ng-file-upload/ng-file-upload.js" />
/// <reference path="lib/ng-table/dist/ng-table.min.js" />
/// <reference path="lib/ui-router/release/angular-ui-router.js" />


text:
#ifndef __LINUX_EDMA_H
#define __LINUX_EDMA_H

struct dma_chan;

#if defined(CONFIG_TI_EDMA) || defined(CONFIG_TI_EDMA_MODULE)
bool edma_filter_fn(struct dma_chan *, void *);
#else
static inline bool edma_filter_fn(struct dma_chan *chan, void *param)
{
	return false;
}
#endif

#endif


text:
package org.hogel.batchsan.core.db.dao;

import com.google.inject.Inject;
import com.j256.ormlite.support.ConnectionSource;
import org.hogel.batchsan.core.db.table.record.S3BackupRecord;

import java.sql.SQLException;

public class S3BackupDao extends BatchDatabaseDao<S3BackupRecord, Long> {
    @Inject
    public S3BackupDao(ConnectionSource connectionSource) throws SQLException {
        super(connectionSource, S3BackupRecord.class);
    }
}