text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
 Copyright (c) 2012-2020 Matt Bertolini

 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.
-->
<project name="macros" basedir="../" xmlns="antlib:org.apache.tools.ant">
    <include file="${basedir}/buildsrc/properties.xml"/>

    <macrodef name="javacompile" uri="antmacro:com.mattbertolini.liquibase.slf4j">
        <attribute name="srcdir"/>
        <attribute name="destdir"/>
        <attribute name="source" default="${ant.java.version}"/>
        <attribute name="target" default="${ant.java.version}"/>
        <element name="compileClasspath" implicit="true" optional="true"/>
        <sequential>
            <mkdir dir="@{destdir}"/>
            <depend srcdir="@{srcdir}" destdir="@{destdir}" cache="${build.temp.dir}" closure="true">
                <include name= "**/*.java"/>
            </depend>
            <javac srcdir="@{srcdir}" destdir="@{destdir}" source="@{source}" target="@{target}" fork="true" failonerror="true" includeantruntime="false" debug="true" encoding="UTF-8">
                <compileClasspath/>
            </javac>
        </sequential>
    </macrodef>

    <macrodef name="processresources" uri="antmacro:com.mattbertolini.liquibase.slf4j">
        <attribute name="dir"/>
        <attribute name="todir"/>
        <sequential>
            <sync todir="@{todir}">
                <fileset dir="@{dir}"/>
                <preserveintarget>
                    <include name="**/*.class"/>
                </preserveintarget>
            </sync>
        </sequential>
    </macrodef>
</project>


text:
namespace amber {
namespace scene {

class Cylinder
: public Primitive
{
public:
  Cylinder(
    const Vector3& center,
    const Vector3& normal,
    real_type radius,
    real_type height
  ) noexcept;

  const Vector3 Center() const noexcept;
  const AABB BoundingBox() const noexcept;
  Hit Intersect(const Ray& ray) const noexcept;

  real_type SurfaceArea() const noexcept;
  Ray SampleSurfacePoint(Sampler& sampler) const;

private:
  Vector3 center_;
  UnitVector3 normal_;
  real_type radius_;
  real_type height_;
  AABB bb_;
};

std::unique_ptr<Primitive>
MakeCylinder(
  const Vector3& center,
  const Vector3& normal,
  real_type radius,
  real_type height
) noexcept
{
  return std::make_unique<Cylinder>(center, normal, radius, height);
}

Cylinder::Cylinder(
  const Vector3& center,
  const Vector3& normal,
  real_type radius,
  real_type height
) noexcept
: center_(center)
, normal_(normal)
, radius_(radius)
, height_(height)
, bb_(AABB::Empty())
{
  bb_ += MakeDisk(center_, normal_, radius_)->BoundingBox();
  bb_ += MakeDisk(center_ + height_ * normal_, normal_, radius_)->BoundingBox();
}

const Vector3
Cylinder::Center() const noexcept
{
  return center_ + height_ / 2 * normal_;
}

const AABB
Cylinder::BoundingBox() const noexcept
{
  return bb_;
}

Hit
Cylinder::Intersect(const Ray& ray) const noexcept
{
  const auto OC = center_ - ray.Origin();
  const auto u = ray.Direction() - Dot(ray.Direction(), normal_) * normal_;
  const auto v = OC - Dot(OC, normal_) * normal_;

  const auto a = SquaredLength(u);
  const auto b = -2 * Dot(u, v);
  const auto c = SquaredLength(v) - radius_ * radius_;

  const auto solutions = prelude::SolveQuadratic(a, b, c);
  if (!solutions) {
    return Hit();
  }

  const auto& alpha = std::get<0>(*solutions);
  const auto& beta = std::get<1>(*solutions);

  if (alpha > kEPS) {
    const auto h = Dot(alpha * ray.Direction() - OC, normal_);
    if (h >= 0 && h <= height_) {
      return Hit(
        ray.Origin() + alpha * ray.Direction(),
        ray.Origin() + alpha * ray.Direction() - center_ - h * normal_,
        alpha
      );
    }
  }

  if (beta > kEPS) {
    const auto h = Dot(beta * ray.Direction() - OC, normal_);
    if (h >= 0 && h <= height_) {
      return Hit(
        ray.Origin() + beta * ray.Direction(),
        ray.Origin() + beta * ray.Direction() - center_ - h * normal_,
        beta
      );
    }
  }

  return Hit();
}

real_type
Cylinder::SurfaceArea() const noexcept
{
  return 2 * static_cast<real_type>(kPI) * radius_ * height_;
}

Ray
Cylinder::SampleSurfacePoint(Sampler& sampler) const
{
  const auto height = prelude::Uniform(height_, sampler);

  Vector3 u, v;
  std::tie(u, v) = OrthonormalBasis(normal_);

  const auto angle = prelude::Circle<real_type>(sampler);

  const auto normal = u * angle.X() + v * angle.Y();
  const auto origin = center_ + normal_ * height + normal * radius_;

  return Ray(origin, normal);
}

}
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace ac\DataBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * Image
 */
class Image
{
    /**
     * @var integer
     */
    private $id;

    /**
     * @var string
     */
    private $originalName;

    /**
     * @var string
     */
    private $path;

    /**
     * Get id
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set originalName
     *
     * @param string $originalName
     * @return Image
     */
    public function setOriginalName($originalName)
    {
        $this->originalName = $originalName;

        return $this;
    }

    /**
     * Get originalName
     *
     * @return string
     */
    public function getOriginalName()
    {
        return $this->originalName;
    }

    /**
     * Set path
     *
     * @param string $path
     * @return Image
     */
    public function setPath($path)
    {
        $this->path = $path;

        return $this;
    }

    /**
     * Get path
     *
     * @return string
     */
    public function getPath()
    {
        return $this->path;
    }
}


text:
FROM reefrt/ubuntu12.04-jdk7
MAINTAINER Apache REEF <dev@reef.apache.org>

# Apache Hadoop 2.7.2
RUN \
  cd /usr/local && wget -q http://www.us.apache.org/dist/hadoop/common/hadoop-2.7.2/hadoop-2.7.2.tar.gz && \
  tar -xzf hadoop-2.7.2.tar.gz && \
  ln -s ./hadoop-2.7.2 hadoop && \
  rm hadoop-2.7.2.tar.gz

ENV HADOOP_PREFIX /usr/local/hadoop
ENV YARN_CONF_DIR /usr/local/hadoop/etc/hadoop
RUN \
  echo 'HADOOP_PREFIX="/usr/local/hadoop"' >> /etc/environment && \
  echo 'HADOOP_COMMON_HOME="/usr/local/hadoop"' >> /etc/environment && \
  echo 'HADOOP_HDFS_HOME="/usr/local/hadoop"' >> /etc/environment && \
  echo 'HADOOP_MAPRED_HOME="/usr/local/hadoop"' >> /etc/environment && \
  echo 'HADOOP_YARN_HOME="/usr/local/hadoop"' >> /etc/environment && \
  echo 'HADOOP_CONF_DIR="/usr/local/hadoop/etc/hadoop"' >> /etc/environment && \
  echo 'YARN_CONF_DIR="/usr/local/hadoop/etc/hadoop"' >> /etc/environment
ENV PATH $PATH:$HADOOP_PREFIX/bin:$HADOOP_PREFIX/sbin:$HADOOP_PREFIX-yarn/bin:$HADOOP_PREFIX-yarn/sbin:$HADOOP_PREFIX-hdfs/bin:$HADOOP_PREFIX-hdfs/sbin

RUN sed -i '/^export JAVA_HOME/ s:.*:export JAVA_HOME=$JAVA_HOME\nexport HADOOP_PREFIX=/usr/local/hadoop\nexport HADOOP_HOME=/usr/local/hadoop\n:' $HADOOP_PREFIX/etc/hadoop/hadoop-env.sh
RUN sed -i '/^export HADOOP_CONF_DIR/ s:.*:export HADOOP_CONF_DIR=/usr/local/hadoop/etc/hadoop/:' $HADOOP_PREFIX/etc/hadoop/hadoop-env.sh

COPY core-site.xml $HADOOP_PREFIX/etc/hadoop/
COPY hdfs-site.xml $HADOOP_PREFIX/etc/hadoop/
COPY mapred-site.xml $HADOOP_PREFIX/etc/hadoop/
COPY yarn-site.xml $HADOOP_PREFIX/etc/hadoop/

RUN chmod +x /usr/local/hadoop/etc/hadoop/*-env.sh
COPY init-nn.sh /root/

EXPOSE 22 7077 8020 8030 8031 8032 8033 8040 8042 8080 8088 10000 50010 50020 50060 50070 50075 50090


text:
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.CloudWatch;
using Amazon.CloudWatch.Model;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
using Amazon.CloudWatchEvents;
using Amazon.CloudWatchEvents.Model;

namespace AWSSDKDocSamples.CloudWatch
{
    class CloudWatchSamples
    {
        static void Main(string[] args)
        {
            // This project contains the following examples:
            //PutRuleExample();
            //PutTargetExample();
            //PutEventExample();
            //EnableAlarmAction("instanceId", "customerAccount");
            //DisableAlarmActions();
            //PutMetricAlarm();
            //CloudWatchMetricsTest();
            //DescribeAlarmForMetric();
            //PutSubscriptionFilters();
            //DescribeSubscriptionFilters();
            //DescribeAlarms();
            //DeleteAlarm(new List < string > { "alarmNames"});
        }
        public static void PutRuleExample()
        {
            AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

            var putRuleRequest = new PutRuleRequest
            {
                Name = "DEMO_EVENT",
                RoleArn = "IAM_ROLE_ARN",
                ScheduleExpression = "rate(5 minutes)",
                State = RuleState.ENABLED
            };

            var putRuleResponse = client.PutRule(putRuleRequest);
            Console.WriteLine("Successfully set the rule {0}", putRuleResponse.RuleArn);
        }
        public static void PutTargetExample()
        {
            AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

            var putTargetRequest = new PutTargetsRequest
            {
                Rule = "DEMO_EVENT",
                Targets =
                {
                    new Target { Arn = "LAMBDA_FUNCTION_ARN", Id = "myCloudWatchEventsTarget"}
                }
            };

            client.PutTargets(putTargetRequest);
        }
        public static void PutEventExample()
        {
            AmazonCloudWatchEventsClient client = new AmazonCloudWatchEventsClient();

            var putEventsRequest = new PutEventsRequest
            {
                Entries = new List<PutEventsRequestEntry>
                {
                    new PutEventsRequestEntry
                    {
                        Detail = @"{ ""key1"" : ""value1"", ""key2"" : ""value2"" }",
                        DetailType = "appRequestSubmitted",
                        Resources =
                        {
                            "RESOURCE_ARN"
                        },
                        Source = "com.compnay.myapp"
                    }
                }
            };

            client.PutEvents(putEventsRequest);
        }
        public static void EnableAlarmAction(string instanceId, string customerAccount)
        {
            using (var client = new AmazonCloudWatchClient(Amazon.RegionEndpoint.USWest2))
            {
                client.PutMetricAlarm(new PutMetricAlarmRequest
                {
                    AlarmName = "Web_Server_CPU_Utilization",
                    ComparisonOperator = ComparisonOperator.GreaterThanThreshold,
                    EvaluationPeriods = 1,
                    MetricName = "CPUUtilization",
                    Namespace = "AWS/EC2",
                    Period = 60,
                    Statistic = Statistic.Average,
                    Threshold = 70.0,
                    ActionsEnabled = true,
                    AlarmActions = new List<string> { "arn:aws:swf:us-west-2:" + customerAccount + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" },
                    AlarmDescription = "Alarm when server CPU exceeds 70%",
                    Dimensions = new List<Dimension>
                    {
                        new Dimension { Name = "InstanceId", Value = instanceId }
                    },
                    Unit = StandardUnit.Seconds
                });

                client.EnableAlarmActions(new EnableAlarmActionsRequest
                {
                    AlarmNames = new List<string> { "Web_Server_CPU_Utilization" }
                });

                MetricDatum metricDatum = new MetricDatum
                { MetricName = "CPUUtilization" };

                PutMetricDataRequest putMetricDatarequest = new PutMetricDataRequest
                {
                    MetricData = new List<MetricDatum> { metricDatum }
                };
                client.PutMetricData(putMetricDatarequest);

            }
        }
        public static void DisableAlarmActions()
        {
            using (var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2))
            {
                client.DisableAlarmActions(new DisableAlarmActionsRequest
                {
                    AlarmNames = new List<string> { "Web_Server_CPU_Utilization" }
                });
            }
        }
        public static void PutMetricAlarm()
        {
            var client = new AmazonCloudWatchClient(RegionEndpoint.USWest2);
            client.PutMetricAlarm(new PutMetricAlarmRequest
            {
                AlarmName = "Web_Server_CPU_Utilization",
                ComparisonOperator = ComparisonOperator.GreaterThanThreshold,
                EvaluationPeriods = 1,
                MetricName = "CPUUtilization",
                Namespace = "AWS/EC2",
                Period = 60,
                Statistic = Statistic.Average,
                Threshold = 70.0,
                ActionsEnabled = true,
                AlarmActions = new List<string> { "arn:aws:swf:us-west-2:" + "customerAccount" + ":action/actions/AWS_EC2.InstanceId.Reboot/1.0" },
                AlarmDescription = "Alarm when server CPU exceeds 70%",
                Dimensions = new List<Dimension>
                    {
                        new Dimension { Name = "InstanceId", Value = "INSTANCE_ID" }
                    },
                Unit = StandardUnit.Seconds
            });

        }
        public static void CloudWatchMetricsTest()
        {
            var logGroupName = "LogGroupName";
            DimensionFilter dimensionFilter = new DimensionFilter()
            {
                Name = logGroupName
            };
            var dimensionFilterList = new List<DimensionFilter>();
            dimensionFilterList.Add(dimensionFilter);

            var dimension = new Dimension
            {
                Name = "UniquePages",
                Value = "URLs"
            };
            using (var cw = new AmazonCloudWatchClient(RegionEndpoint.USWest2))
            {
                var listMetricsResponse = cw.ListMetrics(new ListMetricsRequest
                {
                    Dimensions = dimensionFilterList,
                    MetricName = "IncomingLogEvents",
                    Namespace = "AWS/Logs"
                });

                Console.WriteLine(listMetricsResponse.Metrics);

                cw.PutMetricData(new PutMetricDataRequest
                {
                    MetricData = new List<MetricDatum>{new MetricDatum
                    {
                        MetricName = "PagesVisited",
                        Dimensions = new List<Dimension>{dimension},
                        Unit = "None",
                        Value = 1.0
                    }},
                    Namespace = "SITE/TRAFFIC"
                });

                var describeMetricsResponse = cw.DescribeAlarmsForMetric(new DescribeAlarmsForMetricRequest
                {
                    MetricName = "PagesVisited",
                    Dimensions = new List<Dimension>() { dimension },
                    Namespace = "SITE/TRAFFIC"
                });

                Console.WriteLine(describeMetricsResponse.MetricAlarms);
            }

        }
        public static void DescribeAlarmForMetric()
        {
            var dimension = new Dimension
            {
                Name = "UniquePages",
                Value = "URLs"
            };
            var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2);
            var describeMetricsResponse = cloudWatch.DescribeAlarmsForMetric(new DescribeAlarmsForMetricRequest
            {
                MetricName = "PagesVisited",
                Dimensions = new List<Dimension>() { dimension },
                Namespace = "SITE/TRAFFIC"
            });

            Console.WriteLine(describeMetricsResponse.MetricAlarms);
        }
        public static void PutSubscriptionFilters()
        {
            var client = new AmazonCloudWatchLogsClient();
            var request = new Amazon.CloudWatchLogs.Model.PutSubscriptionFilterRequest()
            {
                DestinationArn = "LAMBDA_FUNCTION_ARN",
                FilterName = "FILTER_NAME",
                FilterPattern = "ERROR",
                LogGroupName = "Log_Group"
            };
            try
            {
                var response = client.PutSubscriptionFilter(request);
            }
            catch (InvalidParameterException e)
            {
                Console.WriteLine(e.Message);
            }

        }
        public static void DescribeSubscriptionFilters()
        {
            var client = new AmazonCloudWatchLogsClient();
            var request = new Amazon.CloudWatchLogs.Model.DescribeSubscriptionFiltersRequest()
            {
                LogGroupName = "GROUP_NAME",
                Limit = 5
            };
            try
            {
                var response = client.DescribeSubscriptionFilters(request);
            }
            catch (Amazon.CloudWatchLogs.Model.ResourceNotFoundException e)
            {
                Console.WriteLine(e.Message);
            }

        }
        public static void DeleteSubscriptionFilter()
        {
            var client = new AmazonCloudWatchLogsClient();
            var request = new Amazon.CloudWatchLogs.Model.DeleteSubscriptionFilterRequest()
            {
                LogGroupName = "GROUP_NAME",
                FilterName = "FILTER"
            };
            try
            {
                var response = client.DeleteSubscriptionFilter(request);
            }
            catch (Amazon.CloudWatchLogs.Model.ResourceNotFoundException e)
            {
                Console.WriteLine(e.Message);
            }

        }
        public static void DescribeAlarms()
        {
            using (var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2))
            {
                var request = new DescribeAlarmsRequest();
                request.StateValue = "INSUFFICIENT_DATA";
                request.AlarmNames = new List<string> { "Alarm1", "Alarm2" };
                do
                {
                    var response = cloudWatch.DescribeAlarms(request);
                    foreach (var alarm in response.MetricAlarms)
                    {
                        Console.WriteLine(alarm.AlarmName);
                    }
                    request.NextToken = response.NextToken;
                } while (request.NextToken != null);
            }
        }
        public static void DeleteAlarm(List<string> alarmNames)
        {
            using (var cloudWatch = new AmazonCloudWatchClient(RegionEndpoint.USWest2))
            {
                var response = cloudWatch.DeleteAlarms(
                    new DeleteAlarmsRequest
                    {
                        AlarmNames = alarmNames
                    });
            }
        }

    }
    }


text:
package main

import (
	"context"

	vision "cloud.google.com/go/vision/apiv1"
	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
)

func main() {
	ctx := context.Background()
	c, err := vision.NewProductSearchClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &visionpb.DeleteReferenceImageRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/vision/v1#DeleteReferenceImageRequest.
	}
	err = c.DeleteReferenceImage(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

// [END vision_v1_generated_ProductSearch_DeleteReferenceImage_sync]


text:
require 'spec_helper'

describe 'Products', vcr: true do
  let(:valid_new_product) { { name: 'Novo Produto' } }
  let(:invalid_new_product) { {} }
  let(:not_found_deal) { { 'id' => 0 } }

  before(:all) do
    client = PipedriveRuby::PipedriveClient.new(ENV['API_TOKEN'])
    @user = {'id'=> ENV['USER_ID']}
    @invalid_user = {'id' => 0}
    @products = client.products
    @products_response = []
  end

  before(:each) do
    @product = @products.create(name: "#{rand(99)} - Novo Produto")
    @products_response << @product
    @another_deal = @products.create(name: "#{rand(99)} - Novo Produto")
    @products_response << @another_deal
    @product = @product['data']
    @another_deal = @another_deal['data']
  end

  after(:all) do
    # delete what left from test on sandbox
    @products_response.each do |product|
      @products.remove(product["data"])
    end
  end

  describe '#add_follower' do
    context 'when success' do
      it 'return success true' do
        response = @products.add_follower(@product,@user)
        expect(response['success']).to be_truthy
      end
    end

    context 'when fails' do
      it 'return success false' do
        response = @products.add_follower(@product,@invalid_user)
        expect(response['success']).to be_falsey
      end
    end
  end # end of add_follower

  describe '#create' do
    context 'when success' do
      it 'return success true' do
        response = @products.create(valid_new_product)
        expect(response['success']).to be_truthy
      end
      it 'return Hash with title inside data' do
        response = @products.create(valid_new_product)
        expect(response['data']['name']).to be == valid_new_product[:name]
      end
    end

    context 'when fails' do
      it 'return success false' do
        response = @products.create(invalid_new_product)
        expect(response['success']).to be_falsey
      end
    end
  end # end of create

  describe '#all' do
    context 'when success' do
      it 'returns a list of products' do
        response = @products.all
        expect(response['success']).to be_truthy
        expect(response['data']).to respond_to(:each)
      end
    end
  end # end of all

  describe '#delete' do
    context 'when success' do
      it 'returns success true' do
        response = @products.remove(@product)
        expect(response['success']).to be_truthy
      end
    end
    context 'when fails' do
      it 'returns success false' do
        response = @products.remove(not_found_deal)
        expect(response['success']).to be_falsey
      end
    end
  end # end of delete

  describe '#delete_follower' do
    context 'when success' do
      it 'return success true' do
        follower_response = @products.add_follower(@product,@user)
        follower = {'id' => follower_response['data']['id']}
        response = @products.delete_follower(@product,follower)
        expect(response['success']).to be_truthy
      end
    end

    context 'when fails' do
      it 'return success false' do
        @products.add_follower(@product,@user)
        response = @products.delete_follower(@product,@invalid_user)
        expect(response['success']).to be_falsey
      end
    end
  end # end of delete_follower

  describe '#find' do
    context 'when success' do
      it 'returns success true' do
        response = @products.find(@product['id'])
        expect(response['success']).to be_truthy
      end
    end
    context 'when fails' do
      it 'return success false' do
        response = @products.find(not_found_deal['id'])
        expect(response['success']).to be_falsey
      end
    end
  end # end of find

  describe '#find_by_name' do
    context 'when success' do
      it 'returns success true' do
        response = @products.find_by_name(@product['name'])
        expect(response['success']).to be_truthy
      end
    end
    context 'when not found' do
      it 'return data nil' do
        response = @products.find_by_name('not exist')
        expect(response['data']).to be_nil
      end
    end
  end # end of find_by_name

  describe '#followers' do
    context 'when success' do
      it 'returns success true' do
        response = @products.followers(@product)
        expect(response['success']).to be_truthy
      end
    end
    context 'when not found' do
      it 'return data nil' do
        response = @products.followers(not_found_deal)
        expect(response['data']).to be_nil
      end
    end
  end # end of followers

  describe '#permitted_users' do
    context 'when success' do
      it 'return success true' do
        response = @products.permitted_users(@product)
        expect(response['success']).to be_truthy
      end
    end

    context 'when fails' do
      it 'return success false' do
        response = @products.permitted_users(invalid_new_product)
        expect(response['success']).to be_falsey
      end
    end
  end # end of permitted_users

  describe '#deals' do
    context 'when success' do
      it 'returns success true' do
        response = @products.deals(@product)
        expect(response['success']).to be_truthy
      end
    end
    context 'when fails' do
      it 'return success false' do
        response = @products.deals(not_found_deal)
        expect(response['data']).to be_falsey
      end
    end
  end # end of deals

  describe '#files' do
    context 'when success' do
      it 'return success true' do
        response = @products.files(@product)
        expect(response['success']).to be_truthy
      end
    end

    context 'when fails' do
      it 'return success false' do
        response = @products.files(invalid_new_product)
        expect(response['success']).to be_falsey
      end
    end
  end # end of files

  describe '#update' do
    context 'when success' do
      it 'returns success true' do
        @products_response << @products.create(name: "#{rand(99)} - Novo Produto")
        response = @products.update(@products_response.last['data'])
        expect(response['success']).to be_truthy
      end
    end

    context 'when not found' do
      it 'returns success false' do
        response = @products.update(not_found_deal)
        expect(response['success']).to be_falsey
      end
    end
  end # end of update

end # end of Products Resource


text:
#ifndef _FPU_CONTROL_H
# define _FPU_CONTROL_H

# include <features.h>

/* These bits are reserved are not changed.  */
# define _FPU_RESERVED 0x070700FC

/* The fdlibm code requires no interrupts for exceptions.  Don't
   change the rounding mode, it would break long double I/O!  */
#define _FPU_DEFAULT  0x00000000 /* Default value.  */

/* Type of the control word.  */
typedef unsigned int fpu_control_t;

/* Macros for accessing the hardware control word.  */
#define _FPU_GETCW(cw)  __asm__ volatile ("efpc %0,0" : "=d" (cw))
#define _FPU_SETCW(cw)  __asm__ volatile ("sfpc  %0,0" : : "d" (cw))

/* Default control word set at startup.  */
extern fpu_control_t __fpu_control;

#endif /* _FPU_CONTROL_H */


text:
/**
 * Module definition.
 */
define(['./element',
        './factory',
        './utils'],
function(Element, factory, utils) {

  /**
   * `Document` constructor.
   *
   * This class provides an interface for simplified building and traversing of
   * XML documents.  The philosophy follows that of jQuery, in that functions
   * are chainable, but geared towards XML rather than the HTML DOM.
   *
   * Example:
   *
   *     var iq = xml('iq', { type: 'result', from: 'plays.shakespeare.lit', to: 'romeo@montague.net/orchard' })
   *       .c('query', { xmlns: 'http://jabber.org/protocol/disco#info' })
   *       .c('feature', { 'var': 'http://jabber.org/protocol/disco#info' })
   *       .root().toString();
   *
   *     // =>
   *
   *     <iq type="result" from="plays.shakespeare.lit" to="romeo@montague.net/orchard">
   *       <query xmlns="http://jabber.org/protocol/disco#info">
   *         <feature var="http://jabber.org/protocol/disco#info"/>
   *       </query>
   *     </iq>
   *
   * @param {String} name
   * @param {String} ns
   * @param {Object} attrs
   * @api protected
   */
  function Document(name, ns, attrs) {
    if (typeof name == 'string') {
      this._root = build(name, ns, attrs);
    } else if (name instanceof window.Document) {
      this._root = name.documentElement;
    } else if (name instanceof window.Element) {
      this._root = name;
    } else {
      throw new Error('Failed to parse XML')
    }
    this._node = this._root;
  }

  /* Sets the current node to the root node.
   *
   * This function sets the current node to the root node.  This is useful when
   * a deeply nested structure has been constructed, and you want to quickly
   * return to the root (for example, to serialize the document).
   *
   * Example:
   *
   *     xml('root')
   *       .c('child')
   *         .c('grandchild')
   *       .root();
   *
   * @return {Document} for chaining
   * @api public
   */
  Document.prototype.tree =
  Document.prototype.root = function() {
    this._node = this._root;
    return this;
  }

  /* Sets the current node to the parent node.
   *
   * This function sets the current node to the parent node.  This is useful
   * when adding a series of child elements that are siblings.  In this case,
   * `up()` is used to restore the current node to the same nesting level.
   *
   * Example:
   *
   *     xml('root')
   *       .c('child1').up()
   *       .c('child2');
   *
   * @return {Document} for chaining
   * @api public
   */
  Document.prototype.up = function() {
    this._node = this._node.parentNode;
    return this;
  }

  /* Check if the current element has `name` and optional `ns`.
   *
   * Example:
   *
   *     el.is('p');
   *
   *     el.is('div', 'http://www.w3.org/1999/xhtml');
   *
   * @param {String} name
   * @param {String} ns
   * @return {Boolean}
   * @api public
   */
  Document.prototype.is = function(name, ns) {
    if (name == this.name() && (!ns || ns === this.ns())) {
      return true;
    }
    return false;
  }

  /* Get the namespace of the current node.
   *
   * @return {String}
   * @api public
   */
  Document.prototype.ns =
  Document.prototype.namespace = function() {
    return this._node.namespaceURI || this._node.getAttribute('xmlns');
  }

  /* Get the name of the current node.
   *
   * @return {String}
   * @api public
   */
  Document.prototype.name = function() {
    return this._node.localName;
  }

  /* Get the first child with matching `name` and optional `ns` of the current
   * node.
   *
   * Example:
   *
   *     el.child('p');
   *
   *     el.child('div', 'http://www.w3.org/1999/xhtml');
   *
   * @param {String} name
   * @param {String} ns
   * @return {Element}
   * @api public
   */
  Document.prototype.child =
  Document.prototype.getChild = function(name, ns) {
    var el = new Element(this._node);
    return el.child(name, ns);
  }

  /* Get the children with matching `name` and optional `ns` of the current
   * node.
   *
   * Example:
   *
   *     el.children('p');
   *
   *     el.children('div', 'http://www.w3.org/1999/xhtml');
   *
   * @param {String} name
   * @param {String} ns
   * @return {Array} XML element wrappers
   * @api public
   */
  Document.prototype.children = function(name, ns) {
    var el = new Element(this._node);
    return el.children(name, ns);
  }

  /* Appends a child the current node and makes it the new current node.
   *
   * Example:
   *
   *     xml('root').c('child');
   *
   * @param {String} name
   * @param {String} ns
   * @param {Object} attrs
   * @return {Document} for chaining
   * @api public
   */
  Document.prototype.c =
  Document.prototype.append = function(name, ns, attrs) {
    var child;
    if (name._node) {
      child = name._node;
    } else {
      child = build(name, ns, attrs);
    }
    this._node.appendChild(child);
    this._node = child;
    return this;
  }

  /* Get or set the text value of the current node.
   *
   * This function does not move the current node, as text nodes cannot have
   * child nodes.
   *
   * Example:
   *
   *     xml('root').c('child').t('hello');
   *
   *     el.t();  // => 'hello'
   *
   * @param {String} text
   * @return {String|Document} for chaining
   * @api public
   */
  Document.prototype.t =
  Document.prototype.text =
  Document.prototype.getText = function(text) {
    if (!text) {
      var el = new Element(this._node);
      return el.text();
    }
    var child = factory.createTextNode(text);
    this._node.appendChild(child);
    return this;
  }

  /* Gets or sets attributes of the current node.
   *
   * This function does not move the current node.
   *
   * Example:
   *
   *     xml('root').c('child').attr('foo', 'bar');
   *
   *     xml('root').c('child').attr({ foo: bar });
   *
   *     el.attr('foo');  // => 'bar'
   *
   * @param {String} name
   * @param {String} value
   * @return {String|Document} for chaining
   * @api public
   */
  Document.prototype.attrs =
  Document.prototype.attr = function(name, value) {
    if (value || typeof name == 'object') {
      var attrs = {};
      if (value) attrs[name] = value;
      else attrs = name;

      for (var name in attrs) {
        this._node.setAttribute(name, attrs[name]);
      }
      return this;
    }
    return this._node.getAttribute(name);
  }

  /**
   * Returns the XML serialization of this current node.
   *
   * Note: To serialize a whole document, call `root()` prior to invoking
   * `toString()`.
   *
   * @return {String}
   * @api public
   */
  Document.prototype.toString = function() {
    return utils.stringify(this._node);
  }

  /**
   * Builds an XML element with `name`, `attrs`, and optional `ns`.
   *
   * @param {String} name
   * @param {String} ns
   * @param {Object} attrs
   * @return {Element} DOM element
   * @api private
   */
  function build(name, ns, attrs) {
    if (typeof ns == 'object') {
      attrs = ns;
      ns = null;
    }

    var el = ns ? factory.createElementNS(ns, name) : factory.createElement(name);
    for (var name in attrs) {
      el.setAttribute(name, attrs[name]);
    }
    return el;
  }

  return Document;
});


text:
slug: jackets-and-coats
name: Jackets And Coats
---


text:
package com.codepath.apps.twitterEnhanced.fragments;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

import com.codepath.apps.twitterEnhanced.applications.TwitterApplication;
import com.codepath.apps.twitterEnhanced.clients.TwitterClient;
import com.codepath.apps.twitterEnhanced.models.Tweet;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import com.loopj.android.http.JsonHttpResponseHandler;

import org.json.JSONArray;
import org.json.JSONObject;

import java.util.List;

import cz.msebera.android.httpclient.Header;

/**
 * Created by Saranu on 4/1/17.
 */

public class UserTimlineLikesFragment extends UserTimelineFragment {
    private TwitterClient client;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        client = TwitterApplication.getRestClient();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup parent, Bundle savedInstanceState) {
        return super.onCreateView(inflater, parent, savedInstanceState);
    }

    public static UserTimlineLikesFragment newInstance(String screenName) {
        UserTimlineLikesFragment userTimlineLikesFragment = new UserTimlineLikesFragment();
        Bundle args = new Bundle();
        args.putString("screen_name", screenName);
        userTimlineLikesFragment.setArguments(args);
        return userTimlineLikesFragment;
    }

    @Override
    protected void populateTimeline(int page) {
        long id = 0;
        String screenName = getArguments().getString("screen_name");
        boolean scroll = false; //set it later
        if (page != 0) {
            id = tweets.get(tweets.size() - 1).getId() - 1;
            scroll = true;
        }
        client.getFavorites(new JsonHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, JSONArray response) {
                Log.d("DEBUG", response.toString());
                GsonBuilder gsonBuilder = new GsonBuilder();
                gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
                // register type adapters here, specify field naming policy, etc.
                Gson gson = gsonBuilder.create();              //  Tweet[] tarray = gson.fromJson(response.toString(),Tweet[].class);
                List<Tweet> tweetList = gson.fromJson(response.toString(), new TypeToken<List<Tweet>>() {
                }.getType());
                if (tweetList == null || tweetList.isEmpty() || tweetList.size() == 0) {
                    Toast.makeText(getContext(), "NO TWEET LIKES",
                            Toast.LENGTH_LONG).show();
                } else {
                    tweetofflineservice.deleteTweetsoffline();
                    tweetofflineservice.saveTweetsOffline(tweetList);
                    tweets.addAll(tweetList);
                    adapter.notifyDataSetChanged();

                }
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, Throwable throwable, JSONArray errorResponse) {
                Log.d("DEBUG", errorResponse.toString());
                if (errorResponse.toString().contains("Too Many Requests") || errorResponse.toString().contains("Rate limit exceeded")) {
                    Toast.makeText(getContext(), "TOO MANY REQUESTS THIS SESSION",
                            Toast.LENGTH_LONG).show();
                } else Toast.makeText(getContext(), "TOO MANY REQUESTS",
                        Toast.LENGTH_LONG).show();
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, Throwable throwable, JSONObject errorResponse) {
                Log.d("DEBUG", errorResponse.toString());
                if (errorResponse.toString().contains("Too Many Requests")) {
                    Toast.makeText(getContext(), "TOO MANY REQUESTS THIS SESSION",
                            Toast.LENGTH_LONG).show();
                } else Toast.makeText(getContext(), "TOO MANY REQUESTS ??",
                        Toast.LENGTH_LONG).show();

            }

        }, screenName, id, scroll);

    }

}


text:
class CreatePayCharges < ActiveRecord::Migration[4.2]
  def change
    create_table :pay_charges do |t|
      # Some Billable objects use string as ID, add `type: :string` if needed
      t.references :owner, polymorphic: true
      t.string :processor, null: false
      t.string :processor_id, null: false
      t.integer :amount, null: false
      t.integer :amount_refunded
      t.string :card_type
      t.string :card_last4
      t.string :card_exp_month
      t.string :card_exp_year

      t.timestamps
    end
  end
end


text:
1.The data in this table is different in that there are different versions of the same datapoint, there are missing values, and also, the scale is very different, the time intervals are irregular.
The data types are nominal for the agency, interval data for population numbers and ordinal scale for dates or interval scale for time.

2.
($(".wikitable tr:eq(3)").text())
($(".wikitable tr:gt(0)").text())


text:
package uk.org.metfriendly.service;

import com.google.common.base.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import uk.org.metfriendly.model.UnauthorizedException;

@Component
public class LisaService {

    private final ServiceConnector serviceConnector;

    @Value("${serverToken}")
    private String serverToken;

    @Value("${lisaManagerReferenceNumber}")
    private String lisaManagerReferenceNumber;

    @Value("${apiRoot}")
    private String apiRoot;

    @Autowired
    public LisaService(ServiceConnector serviceConnector) {
        this.serviceConnector = serviceConnector;
    }

	public String discoverEndpoints(String accessToken) throws UnauthorizedException {
        return serviceConnector.get(
                apiRoot + "lifetime-isa/manager/"+lisaManagerReferenceNumber,
                "application/vnd.hmrc.1.0+json",
                Optional.of(accessToken));
	}
}


text:
@class DVTFilePath, IDEActivityLogSection, NSString;

@interface IDEBuilderGeneratedFileInfo : NSObject <NSCoding>
{
    int _buildCommand;
    DVTFilePath *_sourceFilePath;
    DVTFilePath *_generatedFilePath;
    int _commandResult;
    NSString *_errorString;
    IDEActivityLogSection *_commandLogSection;
}

@property(readonly) IDEActivityLogSection *commandLogSection; // @synthesize commandLogSection=_commandLogSection;
@property(readonly) NSString *errorString; // @synthesize errorString=_errorString;
@property(readonly) int commandResult; // @synthesize commandResult=_commandResult;
@property(readonly) DVTFilePath *generatedFilePath; // @synthesize generatedFilePath=_generatedFilePath;
@property(readonly) DVTFilePath *sourceFilePath; // @synthesize sourceFilePath=_sourceFilePath;
@property(readonly) int buildCommand; // @synthesize buildCommand=_buildCommand;
- (void).cxx_destruct;
- (id)description;
- (void)encodeWithCoder:(id)arg1;
- (id)initWithCoder:(id)arg1;
- (id)initWithBuildCommand:(int)arg1 sourceFilePath:(id)arg2 generatedFilePath:(id)arg3 commandResult:(int)arg4 errorString:(id)arg5 commandLogSection:(id)arg6;

@end


text:
require_relative "production"

Houndapp::Application.configure do
  config.action_mailer.default_url_options = { :host => ENV['HOST'] }
  config.assets.compress = false
  config.assets.compile = true
  config.assets.digest = false
end


text:
Funkis
======

Ideas repo for game making tools.


text:
var id;
function uploadJobSeeker() {
	var frm = document.getElementById("frmUpload");
	frm.action = "jobSeeker_upload?jobSeekerId=" + id;
	frm.submit();
}

function showwin(jobSeekerId) {
	var windNode = $("#win");
	// windNode.css("display","block");
	// windNode.show("slow");
	windNode.fadeIn("slow");
	id = jobSeekerId;
}

function hide() {
	var windNode = $("#win");

	// windNode.css("display","none");
	// windNode.hide("slow");
	windNode.fadeOut(1000);
}


text:
namespace system_logs {

class ConnectedInputDevicesLogSource : public SystemLogsSource {
 public:
  ConnectedInputDevicesLogSource() : SystemLogsSource("Input") {}
  ConnectedInputDevicesLogSource(const ConnectedInputDevicesLogSource&) =
      delete;
  ConnectedInputDevicesLogSource& operator=(
      const ConnectedInputDevicesLogSource&) = delete;
  ~ConnectedInputDevicesLogSource() override = default;
  // Overridden from SystemLogsSource:
  void Fetch(SysLogsSourceCallback callback) override;

 private:
  void ProcessDeviceFillResponse(const ui::InputDevice dev,
                                 SystemLogsResponse* response,
                                 const std::string& vendor_str,
                                 const std::string& pid_str);
};

}  // namespace system_logs

#endif  // CHROME_BROWSER_ASH_SYSTEM_LOGS_CONNECTED_INPUT_DEVICES_LOG_SOURCE_H_


text:
package neuronet;

public class OutputLayer extends Layer
{
    public OutputLayer(int index, int neuroneCount, Net owner)
    {
        super(index, neuroneCount, owner);
    }
    public void backward(double[] tgt)
    {
        int neuroneCount = getNeuroneCount();
        for(int i=0;i<neuroneCount;i++)
        {
            double out = getNeurone(i).getOut();
            double delta = out * (1 - out)*(tgt[i] - out);
            getNeurone(i).setDelta(delta);
        }
    }

}


text:
package com.yahoo.squidb.utility;

import com.yahoo.squidb.sql.SqlUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Represents a version code of the form {@code major.minor.micro.trailing}.
 */
public class VersionCode implements Comparable<VersionCode> {

    /**
     * Deprecated as this version code is unused by any SquiDB SQL feature
     */
    @Deprecated
    public static final VersionCode V3_7_4 = new VersionCode(3, 7, 4, 0); // Default on API 14, default minimum

    /**
     * Deprecated as this version code is only used for checking if multi-row Insert is supported. It is redefined
     * explicitly in the Insert class so that it is more clear in which context it might be used
     */
    @Deprecated
    public static final VersionCode V3_7_11 = new VersionCode(3, 7, 11, 0); // Support for multi-row insert

    /**
     * Deprecated as this version code is unused by any SquiDB SQL feature
     */
    @Deprecated
    public static final VersionCode V3_8_3 = new VersionCode(3, 8, 3, 0); // Support for common table expressions

    /**
     * This field is deprecated as it is mostly useful in the context of the squidb-sqlite-bindings project. A
     * VersionCode constant that explicitly represents the SQLite version in that module has been added to the
     * SQLiteBindingsAdapter class.
     */
    @Deprecated
    public static final VersionCode LATEST = new VersionCode(3, 15, 0, 0); // Latest version

    private static final String VERSION_REGEX =
            "^([\\d]+)(?:\\.([\\d]+))?(?:\\.([\\d]+))?(?:\\.([\\d]+))?((?:[\\w\\-\\(\\)]+\\.)*[\\w\\-\\(\\)]+)?";
    private static Pattern pattern;

    private final int majorVersion;
    private final int minorVersion;
    private final int microVersion;
    private final int nanoVersion;
    private final String trailing;

    /**
     * @throws IllegalArgumentException if any value is less than zero.
     */
    public VersionCode(int major, int minor, int micro, int nano) {
        this(major, minor, micro, nano, null);
    }

    /**
     * @throws IllegalArgumentException if any value is less than zero.
     */
    public VersionCode(int major, int minor, int micro, int nano, String trailing) {
        if (major < 0 || minor < 0 || micro < 0 || nano < 0) {
            throw new IllegalArgumentException(
                    "Can't use a value less than zero to construct a VersionCode.");
        }
        majorVersion = major;
        minorVersion = minor;
        microVersion = micro;
        nanoVersion = nano;
        this.trailing = trailing;
    }

    /**
     * @return the major version number
     */
    public int getMajorVersion() {
        return majorVersion;
    }

    /**
     * @return the minor version number
     */
    public int getMinorVersion() {
        return minorVersion;
    }

    /**
     * @return the micro version number
     */
    public int getMicroVersion() {
        return microVersion;
    }

    /**
     * @return the nano version number
     */
    public int getNanoVersion() {
        return nanoVersion;
    }

    /**
     * @return the trailing text of the version code
     */
    public String getTrailingText() {
        return trailing;
    }

    /**
     * @return true if the version represented by this object is equal to or greater than the version represented by the
     * {@code version} argument.
     */
    public boolean isAtLeast(VersionCode version) {
        return this.compareTo(version) >= 0;
    }

    /**
     * @return true if the version represented by this object is equal to or greater than the version represented by the
     * {@code versionString} argument.
     */
    public boolean isAtLeast(String versionString) {
        return isAtLeast(parse(versionString));
    }

    /**
     * @return true if the version represented by this object is less than the version represented by the
     * {@code version} argument.
     */
    public boolean isLessThan(VersionCode version) {
        return this.compareTo(version) < 0;
    }

    /**
     * @return true if the version represented by this object is less than the version represented by the
     * {@code versionString} argument.
     */
    public boolean isLessThan(String versionString) {
        return isLessThan(parse(versionString));
    }

    /**
     * Parse a version string of the form {@code major.minor.micro.trailing}.
     * Major, minor, and micro must be numeric. Only the major version number is
     * required to successfully parse the string. If trailing alphanumeric
     * characters (up to the first non-word character) are present, a missing
     * minor or micro version is considered to be 0.
     *
     * <pre>
     * "1"              =<  1.0.0
     * "1.2"            =<  1.2.0
     * "1.2.3"          =<  1.2.3
     * "1.2.3foo"       =<  1.2.3foo
     * "1.2.3foo bar"   =<  1.2.3foo
     * "1foo"           =<  1.0.0foo
     * "1.2foo"         =<  1.2.0foo
     * "foo"            =<  0.0.0
     * </pre>
     *
     * @throws IllegalArgumentException if the input cannot be parsed.
     */
    public static VersionCode parse(String versionString) {
        if (SqlUtils.isEmpty(versionString)) {
            throw new IllegalArgumentException("Empty versionString");
        }

        if (pattern == null) {
            pattern = Pattern.compile(VERSION_REGEX);
        }

        Matcher matcher = pattern.matcher(versionString.trim());
        if (!matcher.find()) {
            throw new IllegalArgumentException("Invalid versionString: " + versionString);
        }

        int major, minor, micro, nano;
        // group(0) is the full match, so start at 1
        // regex guarantees group(1) is not null
        String majorString = matcher.group(1);
        major = Integer.parseInt(majorString);
        String minorString = matcher.group(2);
        minor = minorString == null ? 0 : Integer.parseInt(minorString);
        String microString = matcher.group(3);
        micro = microString == null ? 0 : Integer.parseInt(microString);
        String nanoString = matcher.group(4);
        nano = nanoString == null ? 0 : Integer.parseInt(nanoString);
        String trailing = matcher.group(5);

        return new VersionCode(major, minor, micro, nano, trailing);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof VersionCode)) {
            return false;
        }

        VersionCode other = (VersionCode) o;
        return this.compareTo(other) == 0;
    }

    @Override
    public int compareTo(VersionCode other) {
        if (this == other) {
            return 0;
        }
        int result = this.majorVersion - other.majorVersion;
        if (result != 0) {
            return result;
        }
        result = this.minorVersion - other.minorVersion;
        if (result != 0) {
            return result;
        }
        result = this.microVersion - other.microVersion;
        if (result != 0) {
            return result;
        }
        result = this.nanoVersion - other.nanoVersion;
        if (result != 0) {
            return result;
        }

        if (this.trailing == null) {
            return other.trailing == null ? 0 : -1;
        }

        return other.trailing == null ? 1
                : this.trailing.compareTo(other.trailing);
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(Integer.toString(majorVersion))
                .append('.').append(Integer.toString(minorVersion))
                .append('.').append(Integer.toString(microVersion));
        if (nanoVersion > 0) {
            builder.append('.').append(nanoVersion);
        }
        if (!SqlUtils.isEmpty(trailing)) {
            builder.append(trailing);
        }

        return builder.toString();
    }

    @Override
    public int hashCode() {
        int hash = majorVersion;
        hash = hash * 31 + minorVersion;
        hash = hash * 31 + microVersion;
        hash = hash * 31 + nanoVersion;
        hash = hash * 31 + (trailing == null ? 0 : trailing.hashCode());
        return hash;
    }
}


text:
package org.pentaho.hadoop.mapreduce.converter.converters;

import org.apache.hadoop.io.Text;
import org.junit.Test;

import static org.junit.Assert.*;

public class TextToStringConverterTest {
  @Test
  public void canConvert() throws Exception {
    TextToStringConverter c = new TextToStringConverter();

    assertTrue(c.canConvert(Text.class, String.class));

    assertFalse(c.canConvert(null, null));
    assertFalse(c.canConvert(Text.class, Object.class));
    assertFalse(c.canConvert(Object.class, String.class));
  }

  @Test
  public void convert() throws Exception {
    TextToStringConverter c = new TextToStringConverter();
    String expected = "hello";

    assertEquals(expected, c.convert(null, new Text(expected)));

    try {
      c.convert(null, null);
      fail();
    } catch (NullPointerException ex) {
      // Expected
    }
  }
}


text:
package com.nominanuda.hyperapi;

import java.io.IOException;
import java.io.InputStream;

import okhttp3.ResponseBody;

public class InputStreamEntityDecoder extends AbstractEntityDecoder<InputStream> {

	public InputStreamEntityDecoder() {
		super(InputStream.class, ANY_CONTENT_TYPE);
	}

	@Override
	protected InputStream decodeInternal(AnnotatedType p, ResponseBody entity) throws IOException {
		return entity.byteStream();
	}
}


text:
<?php

namespace Heystack\Core\Traits;

use Heystack\Core\State\State;

/**
 * Allows a using class to set a state service
 * @package Heystack\Core\Traits
 */
trait HasStateServiceTrait
{
    /**
     * @var \Heystack\Core\State\State
     */
    protected $stateService;

    /**
     * @param \Heystack\Core\State\State $stateService
     * @return void
     */
    public function setStateService(State $stateService)
    {
        $this->stateService = $stateService;
    }

    /**
     * @return \Heystack\Core\State\State
     */
    public function getStateService()
    {
        return $this->stateService;
    }
}


text:
extern int verbose;
extern pthread_mutex_t settings_lock;
extern dictionary *Site_INI;
extern int trigger_type;
extern int32 gpsrate;

void *settings_parse_ini_file(struct SiteSettings *ros_settings) {
     int temp_int;

     pthread_mutex_unlock(&settings_lock);
     ros_settings->ifmode=iniparser_getboolean(Site_INI,"site_settings:ifmode",IF_DISABLED);
     sprintf(ros_settings->name,"%s",iniparser_getstring(Site_INI,"site_settings:name",SITE_NAME));
     temp_int=iniparser_getint(Site_INI,"site_settings:trigger_type",0);
     switch(temp_int) {
       case 0:
       case 1:
       case 2:
         trigger_type=temp_int;
         gpsrate=iniparser_getint(Site_INI,"gps:trigger_rate",1);
         break;
       default:
         trigger_type=0;
         break;
     }
     pthread_mutex_unlock(&settings_lock);
     pthread_exit(NULL);

}

void *settings_rxfe_update_rf(struct RXFESettings *rxfe_rf_settings)
{

  pthread_mutex_lock(&settings_lock);

     if( verbose > 1 ) fprintf(stderr,"RXFE RF Mode Settings from INI File ::\n");

     rxfe_rf_settings->ifmode=0;
     if( verbose > 1 ) fprintf(stderr,"RXFE :: IF: %d\n",rxfe_rf_settings->ifmode);

     rxfe_rf_settings->amp1=iniparser_getboolean(Site_INI,"rxfe_rf:enable_amp1",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp1: %d\n",rxfe_rf_settings->amp1);
     rxfe_rf_settings->amp2=iniparser_getboolean(Site_INI,"rxfe_rf:enable_amp2",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp2: %d\n",rxfe_rf_settings->amp2);
     rxfe_rf_settings->amp3=iniparser_getboolean(Site_INI,"rxfe_rf:enable_amp3",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp3: %d\n",rxfe_rf_settings->amp3);

     rxfe_rf_settings->att1=iniparser_getboolean(Site_INI,"rxfe_rf:enable_att1",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att1: %d\n",rxfe_rf_settings->att1);
     rxfe_rf_settings->att2=iniparser_getboolean(Site_INI,"rxfe_rf:enable_att2",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att2: %d\n",rxfe_rf_settings->att2);
     rxfe_rf_settings->att3=iniparser_getboolean(Site_INI,"rxfe_rf:enable_att3",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att3: %d\n",rxfe_rf_settings->att3);
     rxfe_rf_settings->att4=iniparser_getboolean(Site_INI,"rxfe_rf:enable_att4",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att4: %d\n",rxfe_rf_settings->att4);

  pthread_mutex_unlock(&settings_lock);
  pthread_exit(NULL);
}

void *settings_rxfe_update_if(struct RXFESettings *rxfe_if_settings)
{

  pthread_mutex_lock(&settings_lock);

     if( verbose > 1 ) fprintf(stderr,"RXFE IF Mode Settings from INI File ::\n");

     rxfe_if_settings->ifmode=1;
     if( verbose > 1 ) fprintf(stderr,"RXFE :: IF: %d\n",rxfe_if_settings->ifmode);

     rxfe_if_settings->amp1=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp1",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp1: %d\n",rxfe_if_settings->amp1);
     rxfe_if_settings->amp2=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp2",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp2: %d\n",rxfe_if_settings->amp2);
     rxfe_if_settings->amp3=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp3",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: amp3: %d\n",rxfe_if_settings->amp3);

     rxfe_if_settings->att1=iniparser_getboolean(Site_INI,"rxfe_if:enable_att1",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att1: %d\n",rxfe_if_settings->att1);
     rxfe_if_settings->att2=iniparser_getboolean(Site_INI,"rxfe_if:enable_att2",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att2: %d\n",rxfe_if_settings->att2);
     rxfe_if_settings->att3=iniparser_getboolean(Site_INI,"rxfe_if:enable_att3",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att3: %d\n",rxfe_if_settings->att3);
     rxfe_if_settings->att4=iniparser_getboolean(Site_INI,"rxfe_if:enable_att4",0);
     if( verbose > 1 ) fprintf(stderr,"RXFE :: att4: %d\n",rxfe_if_settings->att4);

  pthread_mutex_unlock(&settings_lock);
  pthread_exit(NULL);
}


text:
<?php

App::uses('File', 'Utility');
App::uses('Folder', 'Utility');
App::uses('ExtensionsAppController', 'Extensions.Controller');
App::uses('ExtensionsInstaller', 'Extensions.Lib');
App::uses('CroogoTheme', 'Extensions.Lib');
App::uses('Sanitize', 'Utility');

/**
 * Extensions Themes Controller
 *
 * @category Controller
 * @package  Croogo.Extensions.Controller
 * @version  1.0
 * @author   Fahad Ibnay Heylaal <contact@fahad19.com>
 * @license  http://www.opensource.org/licenses/mit-license.php The MIT License
 * @link     http://www.croogo.org
 */
class ExtensionsThemesController extends ExtensionsAppController {

/**
 * Controller name
 *
 * @var string
 * @access public
 */
	public $name = 'ExtensionsThemes';

/**
 * Models used by the Controller
 *
 * @var array
 * @access public
 */
	public $uses = array(
		'Settings.Setting',
		'Users.User',
	);

/**
 * CroogoTheme instance
 */
	protected $_CroogoTheme = false;

/**
 * Constructor
 */
	public function __construct($request = null, $response = null) {
		$this->_CroogoTheme = new CroogoTheme();
		parent::__construct($request, $response);
	}

/**
 * admin_index
 *
 * @return void
 */
	public function admin_index() {
		$this->set('title_for_layout', __d('croogo', 'Themes'));

		$themes = $this->_CroogoTheme->getThemes();
		$themesData = array();
		$themesData[] = $this->_CroogoTheme->getData();
		foreach ($themes as $theme) {
			$themesData[$theme] = $this->_CroogoTheme->getData($theme);
		}

		$currentTheme = $this->_CroogoTheme->getData(Configure::read('Site.theme'));
		$this->set(compact('themes', 'themesData', 'currentTheme'));
	}

/**
 * admin_activate
 *
 * @param string $alias
 * @return void
 */
	public function admin_activate($alias = null) {
		if ($this->_CroogoTheme->activate($alias)) {
			$this->Session->setFlash(__d('croogo', 'Theme activated.'), 'default', array('class' => 'success'));
		} else {
			$this->Session->setFlash(__d('croogo', 'Theme activation failed.'), 'default', array('class' => 'success'));
		}

		$this->redirect(array('action' => 'index'));
	}

/**
 * admin_add
 *
 * @return void
 */
	public function admin_add() {
		$this->set('title_for_layout', __d('croogo', 'Upload a new theme'));

		if (!empty($this->request->data)) {
			$file = $this->request->data['Theme']['file'];
			unset($this->request->data['Theme']['file']);

			$Installer = new ExtensionsInstaller;
			try {
				$Installer->extractTheme($file['tmp_name']);
				$this->Session->setFlash(__d('croogo', 'Theme uploaded successfully.'), 'default', array('class' => 'success'));
			} catch (CakeException $e) {
				$this->Session->setFlash($e->getMessage(), 'default', array('class' => 'error'));
			}
			$this->redirect(array('action' => 'index'));
		}
	}

/**
 * admin_editor
 *
 * @return void
 */
	public function admin_editor() {
		$this->set('title_for_layout', __d('croogo', 'Theme Editor'));
	}

/**
 * admin_save
 *
 * @return void
 */
	public function admin_save() {
	}

/**
 * admin_delete
 *
 * @param string $alias
 * @return void
 */
	public function admin_delete($alias = null) {
		if ($alias == null) {
			$this->Session->setFlash(__d('croogo', 'Invalid Theme.'), 'default', array('class' => 'error'));
			$this->redirect(array('action' => 'index'));
		}

		if ($alias == 'default') {
			$this->Session->setFlash(__d('croogo', 'Default theme cannot be deleted.'), 'default', array('class' => 'error'));
			$this->redirect(array('action' => 'index'));
		} elseif ($alias == Configure::read('Site.theme')) {
			$this->Session->setFlash(__d('croogo', 'You cannot delete a theme that is currently active.'), 'default', array('class' => 'error'));
			$this->redirect(array('action' => 'index'));
		}

		$result = $this->_CroogoTheme->delete($alias);

		if ($result === true) {
			$this->Session->setFlash(__d('croogo', 'Theme deleted successfully.'), 'default', array('class' => 'success'));
		} elseif (!empty($result[0])) {
			$this->Session->setFlash($result[0], 'default', array('class' => 'error'));
		} else {
			$this->Session->setFlash(__d('croogo', 'An error occurred.'), 'default', array('class' => 'error'));
		}

		$this->redirect(array('action' => 'index'));
	}

}


text:
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Partial Class frmLink
    Inherits System.Windows.Forms.Form

    'Form overrides dispose to clean up the component list.
    <System.Diagnostics.DebuggerNonUserCode()> _
    Protected Overrides Sub Dispose(ByVal disposing As Boolean)
        Try
            If disposing AndAlso components IsNot Nothing Then
                components.Dispose()
            End If
        Finally
            MyBase.Dispose(disposing)
        End Try
    End Sub

    'Required by the Windows Form Designer
    Private components As System.ComponentModel.IContainer

    'NOTE: The following procedure is required by the Windows Form Designer
    'It can be modified using the Windows Form Designer.
    'Do not modify it using the code editor.
    <System.Diagnostics.DebuggerStepThrough()> _
    Private Sub InitializeComponent()
        Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(frmLink))
        Me.splMain = New System.Windows.Forms.SplitContainer()
        Me.picBox = New System.Windows.Forms.PictureBox()
        Me.btnEmail = New System.Windows.Forms.Button()
        Me.btnOpenLoc = New System.Windows.Forms.Button()
        Me.btnPreview = New System.Windows.Forms.Button()
        Me.btnClose = New System.Windows.Forms.Button()
        Me.splMain.Panel1.SuspendLayout()
        Me.splMain.Panel2.SuspendLayout()
        Me.splMain.SuspendLayout()
        CType(Me.picBox, System.ComponentModel.ISupportInitialize).BeginInit()
        Me.SuspendLayout()
        '
        'splMain
        '
        Me.splMain.Dock = System.Windows.Forms.DockStyle.Fill
        Me.splMain.FixedPanel = System.Windows.Forms.FixedPanel.Panel2
        Me.splMain.IsSplitterFixed = True
        Me.splMain.Location = New System.Drawing.Point(0, 0)
        Me.splMain.Name = "splMain"
        Me.splMain.Orientation = System.Windows.Forms.Orientation.Horizontal
        '
        'splMain.Panel1
        '
        Me.splMain.Panel1.Controls.Add(Me.picBox)
        '
        'splMain.Panel2
        '
        Me.splMain.Panel2.Controls.Add(Me.btnEmail)
        Me.splMain.Panel2.Controls.Add(Me.btnOpenLoc)
        Me.splMain.Panel2.Controls.Add(Me.btnPreview)
        Me.splMain.Panel2.Controls.Add(Me.btnClose)
        Me.splMain.Panel2MinSize = 105
        Me.splMain.Size = New System.Drawing.Size(565, 385)
        Me.splMain.SplitterDistance = 274
        Me.splMain.TabIndex = 0
        '
        'picBox
        '
        Me.picBox.Dock = System.Windows.Forms.DockStyle.Fill
        Me.picBox.Location = New System.Drawing.Point(0, 0)
        Me.picBox.Name = "picBox"
        Me.picBox.Size = New System.Drawing.Size(565, 274)
        Me.picBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom
        Me.picBox.TabIndex = 0
        Me.picBox.TabStop = False
        '
        'btnEmail
        '
        Me.btnEmail.Anchor = System.Windows.Forms.AnchorStyles.Top
        Me.btnEmail.BackColor = System.Drawing.Color.Transparent
        Me.btnEmail.BackgroundImage = CType(resources.GetObject("btnEmail.BackgroundImage"), System.Drawing.Image)
        Me.btnEmail.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch
        Me.btnEmail.FlatAppearance.BorderSize = 0
        Me.btnEmail.FlatStyle = System.Windows.Forms.FlatStyle.Flat
        Me.btnEmail.Location = New System.Drawing.Point(299, 3)
        Me.btnEmail.Name = "btnEmail"
        Me.btnEmail.Size = New System.Drawing.Size(100, 100)
        Me.btnEmail.TabIndex = 18
        Me.btnEmail.UseVisualStyleBackColor = False
        '
        'btnOpenLoc
        '
        Me.btnOpenLoc.Anchor = System.Windows.Forms.AnchorStyles.Top
        Me.btnOpenLoc.BackColor = System.Drawing.Color.Transparent
        Me.btnOpenLoc.BackgroundImage = CType(resources.GetObject("btnOpenLoc.BackgroundImage"), System.Drawing.Image)
        Me.btnOpenLoc.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch
        Me.btnOpenLoc.FlatAppearance.BorderSize = 0
        Me.btnOpenLoc.FlatStyle = System.Windows.Forms.FlatStyle.Flat
        Me.btnOpenLoc.Location = New System.Drawing.Point(24, 3)
        Me.btnOpenLoc.Name = "btnOpenLoc"
        Me.btnOpenLoc.Size = New System.Drawing.Size(100, 100)
        Me.btnOpenLoc.TabIndex = 17
        Me.btnOpenLoc.UseVisualStyleBackColor = False
        '
        'btnPreview
        '
        Me.btnPreview.Anchor = System.Windows.Forms.AnchorStyles.Top
        Me.btnPreview.BackColor = System.Drawing.Color.Transparent
        Me.btnPreview.BackgroundImage = CType(resources.GetObject("btnPreview.BackgroundImage"), System.Drawing.Image)
        Me.btnPreview.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch
        Me.btnPreview.FlatAppearance.BorderSize = 0
        Me.btnPreview.FlatStyle = System.Windows.Forms.FlatStyle.Flat
        Me.btnPreview.Location = New System.Drawing.Point(160, 3)
        Me.btnPreview.Name = "btnPreview"
        Me.btnPreview.Size = New System.Drawing.Size(100, 100)
        Me.btnPreview.TabIndex = 16
        Me.btnPreview.UseVisualStyleBackColor = False
        '
        'btnClose
        '
        Me.btnClose.Anchor = System.Windows.Forms.AnchorStyles.Top
        Me.btnClose.BackColor = System.Drawing.Color.Transparent
        Me.btnClose.BackgroundImage = CType(resources.GetObject("btnClose.BackgroundImage"), System.Drawing.Image)
        Me.btnClose.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch
        Me.btnClose.FlatAppearance.BorderSize = 0
        Me.btnClose.FlatStyle = System.Windows.Forms.FlatStyle.Flat
        Me.btnClose.Location = New System.Drawing.Point(431, 3)
        Me.btnClose.Name = "btnClose"
        Me.btnClose.Size = New System.Drawing.Size(100, 100)
        Me.btnClose.TabIndex = 15
        Me.btnClose.UseVisualStyleBackColor = False
        '
        'frmLink
        '
        Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
        Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
        Me.ClientSize = New System.Drawing.Size(565, 385)
        Me.ControlBox = False
        Me.Controls.Add(Me.splMain)
        Me.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D
        Me.MaximizeBox = False
        Me.MinimizeBox = False
        Me.Name = "frmLink"
        Me.ShowInTaskbar = False
        Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen
        Me.Text = "  "
        Me.splMain.Panel1.ResumeLayout(False)
        Me.splMain.Panel2.ResumeLayout(False)
        Me.splMain.ResumeLayout(False)
        CType(Me.picBox, System.ComponentModel.ISupportInitialize).EndInit()
        Me.ResumeLayout(False)

    End Sub
    Friend WithEvents splMain As System.Windows.Forms.SplitContainer
    Friend WithEvents picBox As System.Windows.Forms.PictureBox
    Friend WithEvents btnEmail As System.Windows.Forms.Button
    Friend WithEvents btnOpenLoc As System.Windows.Forms.Button
    Friend WithEvents btnPreview As System.Windows.Forms.Button
    Friend WithEvents btnClose As System.Windows.Forms.Button
End Class


text:
=================
Handle Exceptions
=================

Question
--------

ADDQUESTION

Solution
--------

.. literalinclude:: ../../languages/ruby/handle_exceptions.rb
   :language: ruby
   :tab-width: 4

.. runcode:: ../../languages/ruby/handle_exceptions.rb
   :language: ruby
   :codesite: ideone

Explanation
===========

.. git_changelog::

.. seealso::

   * :ruby-suggest-improve:`handle_exceptions.rb`
   * :ruby-better-explain:`handle_exceptions.rst`


text:
/* ----------------------------------------------------------------------
 * Project:      CMSIS DSP Library
 * Title:        arm_pid_init_q31.c
 * Description:  Q31 PID Control initialization function
 *
 * $Date:        23 April 2021
 * $Revision:    V1.9.0
 *
 * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
/*
 * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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
 *
 * 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.
 */

#include "dsp/controller_functions.h"

/**
  @addtogroup PID
  @{
 */

/**
  @brief         Initialization function for the Q31 PID Control.
  @param[in,out] S               points to an instance of the Q31 PID structure
  @param[in]     resetStateFlag
                   - value = 0: no change in state
                   - value = 1: reset state
  @return        none

  @par           Details
                   The resetStateFlag specifies whether to set state to zero or not. \n
                   The function computes the structure fields: A0, A1 A2
                   using the proportional gain( \c Kp), integral gain( \c Ki) and derivative gain( \c Kd)
                   also sets the state variables to all zeros.
 */

void arm_pid_init_q31(
  arm_pid_instance_q31 * S,
  int32_t resetStateFlag)
{

#if defined (ARM_MATH_DSP)

  /* Derived coefficient A0 */
  S->A0 = __QADD(__QADD(S->Kp, S->Ki), S->Kd);

  /* Derived coefficient A1 */
  S->A1 = -__QADD(__QADD(S->Kd, S->Kd), S->Kp);

#else

  q31_t temp;                                    /* to store the sum */

  /* Derived coefficient A0 */
  temp = clip_q63_to_q31((q63_t) S->Kp + S->Ki);
  S->A0 = clip_q63_to_q31((q63_t) temp + S->Kd);

  /* Derived coefficient A1 */
  temp = clip_q63_to_q31((q63_t) S->Kd + S->Kd);
  S->A1 = -clip_q63_to_q31((q63_t) temp + S->Kp);

#endif /* #if defined (ARM_MATH_DSP) */

  /* Derived coefficient A2 */
  S->A2 = S->Kd;

  /* Check whether state needs reset or not */
  if (resetStateFlag)
  {
    /* Reset state to zero, The size will be always 3 samples */
    memset(S->state, 0, 3U * sizeof(q31_t));
  }

}

/**
  @} end of PID group
 */


text:
using namespace std;

namespace Ped {
class Tscene;
class Twaypoint;

/// \example example.cpp

/// This is the main class of the library. It contains the Tagent, which eventually will move through the
/// Tscene and interact with Tobstacle and other Tagent. You can use it as it is, and access the agent's
/// coordinates using the getx() etc methods. Or, if you want to change the way the agent behaves, you can
/// derive a new class from it, and overwrite the methods you want to change. This is also a convenient way
/// to get access to internal variables not available though public methods, like the individual forces that
/// affect the agent.
/// \author  chgloor
/// \date    2003-12-26
class LIBEXPORT Tagent {

public:
    enum AgentType {
        ADULT = 0,
        CHILD = 1,
        ROBOT = 2,
        ELDER = 3
    };

    Tagent();
    virtual ~Tagent();

    virtual void updateState(){};
    virtual void computeForces();
    virtual void move(double stepSizeIn);
    virtual Tvector desiredForce();
    virtual Tvector socialForce() const;
    virtual Tvector obstacleForce() const;
    virtual Tvector myForce(Tvector desired) const;
    virtual Twaypoint* getCurrentWaypoint() const = 0;

    virtual void setPosition(double px, double py, double pz = 0);
    virtual void setType(AgentType typeIn) { type = typeIn; };
    virtual void setVmax(double vmax);
    virtual void SetRadius(double radius) { agentRadius = radius; }

    void setTeleop(bool opstatus) { teleop = opstatus; }

    int getId() const { return id; };
    AgentType getType() const { return type; };
    double getVmax() const { return vmax; };
    double getRelaxationTime() const { return relaxationTime; };
    bool getTeleop() { return teleop; }

    // these getter should replace the ones later (returning the individual vector values)
    const Tvector& getPosition() const { return p; }
    const Tvector& getVelocity() const { return v; }
    const Tvector& getAcceleration() const { return a; }

    double getx() const { return p.x; };
    double gety() const { return p.y; };
    double getz() const { return p.z; };
    double getvx() const { return v.x; };
    double getvy() const { return v.y; };
    double getvz() const { return v.z; };
    double getax() const { return a.x; };
    double getay() const { return a.y; };
    double getaz() const { return a.z; };

    void setvx(double vv) { v.x = vv; }
    void setvy(double vv) { v.y = vv; }

    virtual void setForceFactorDesired(double f);
    virtual void setForceFactorSocial(double f);
    virtual void setForceFactorObstacle(double f);

    void assignScene(Tscene* sceneIn);
    void removeAgentFromNeighbors(const Tagent* agentIn);

protected:
    int id;
    Tvector p; ///< current position of the agent
    Tvector v; ///< current velocity of the agent
    Tvector a; ///< current acceleration of the agent
    AgentType type;
    double vmax;
    double agentRadius;
    double relaxationTime;
    bool teleop;

    double forceFactorDesired;
    double forceFactorSocial;
    double forceFactorObstacle;
    double forceSigmaObstacle;

    Ped::Tscene* scene;

    Ped::Tvector desiredDirection;
    set<const Ped::Tagent*> neighbors;

    Ped::Tvector desiredforce;
    Ped::Tvector socialforce;
    Ped::Tvector obstacleforce;
    Ped::Tvector myforce;
};
}
#endif


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
Am. Midl. Nat. 4: 378 (1916)

#### Original name
Culicicola Nieuwl.

### Remarks
null


text:
<?php

namespace actsmart\actsmart;

use InvalidArgumentException;

class NLPInterpretDoesNotExistException extends InvalidArgumentException
{
    //
}


text:
var sequential = function() {

  var intervals = [];

  var Interval = function(from, to) {
    this.id = ++Interval.prototype.id;
    this.from = from;
    this.to = to;
    this.overlap = [];
  }

  Interval.prototype.id = 0;
  Interval.const = Interval.prototype;
  Interval.prototype.SUBSET = 1;
  Interval.prototype.DISJOINT = 2;
  Interval.prototype.INTERSECT_OR_SUPERSET = 3;

  Interval.prototype.compareTo = function(other) {
    if (other.from > this.to || other.to < this.from) return this.DISJOINT;
    if (other.from <= this.from && other.to >= this.to) return this.SUBSET;
    return this.INTERSECT_OR_SUPERSET;
  }

  // endpoints of intervals included
  Interval.prototype.disjointIncl = function(other) {
    if (other.from > this.to || other.to < this.from) return this.DISJOINT;
  }

  // two intervals that share only endpoints are seen as disjoint
  Interval.prototype.disjointExcl = function(other) {
    if (other.from >= this.to || other.to <= this.from) return this.DISJOINT;
  }

  var validateInterval = function(from, to) {
    if (typeof from !== 'number' || typeof to !== 'number') throw {
        name: 'InvalidInterval',
        message: 'endpoints of interval must be of type number'
    };
    if (from > to) throw {
        name: 'InvalidInterval',
        message: '(' + from + ',' + to + ')' + ' a > b'
    };
  }

  var validateIntervalArray = function(from, to) {
    if (!(from instanceof Array && to instanceof Array)) throw {
        name: 'InvalidParameter',
        message: 'function pushArray: parameters must be arrays'
    };
    if (from.length !== to.length) throw {
        name: 'InvalidParameter',
        message: 'function pushArray: arrays must have same length'
    };
    for(var i = 0; i < from.length; i++) {
      validateInterval(from[i], to[i]);
    }
  }

  var validatePoint = function(point) {
    if (typeof point !== 'number') throw {
        name: 'InvalidParameter',
        message: 'parameter must be a number'
    };
  }

  var validatePointArray = function(points) {
    if (!(points instanceof Array)) throw {
        name: 'InvalidParameter',
        message: 'parameter must be an array'
    };
    for(var i = 0; i < points.length; i++) {
      if (typeof points[i] !== 'number') throw {
        name: 'InvalidParameter',
        message: 'array must consist only of numbers'
      }
    }
  }

  var _query = function(queryIntervals, hits, disjointFn) {
    queryIntervals.forEach(function(queryInterval) {
      intervals.forEach(function(interval) {
        if (disjointFn.call(interval, queryInterval) !== Interval.const.DISJOINT) {
          hits[interval.id] = interval;
        }
      });
    });
  }

  var _queryInterval = function(intervalArray, resultFn, disjointFn) {
    var hits = {};
    if (disjointFn === undefined) disjointFn = Interval.prototype.disjointIncl;
    _query(intervalArray, hits, disjointFn);
    var intervalArray = Object.keys(hits).map(function(key) {
      return hits[key];
    });
    if (resultFn !== undefined && typeof resultFn === 'function') resultFn(intervalArray);
    return intervalArray.length;
  }

  var _queryOverlap = function(disjointFn) {
    for(var i = 0; i < intervals.length; i++) {
      for(var h = i + 1; h < intervals.length; h++) {
        if (disjointFn.call(intervals[i], intervals[h]) !== Interval.const.DISJOINT) {
          intervals[i].overlap.push(intervals[h].id.toString());
          intervals[h].overlap.push(intervals[i].id.toString());
        }
      }
    }
  }

  return {
    pushInterval: function(from, to) {
      validateInterval(from, to);
      intervals.push(new Interval(from, to));
    },
    pushArray: function(from, to, validate) {
      var val = (validate !== undefined) ? validate : true;
      if (val) validateIntervalArray(from, to);
      for(var i = 0; i < from.length; i++) {
        intervals.push(new Interval(from[i], to[i]));
      }
    },
    clearIntervalStack: function() {
      intervals.length = 0;
      Interval.prototype.id = 0;
    },
    queryPoint: function(point, resultFn) {
      validatePoint(point);
      return this.queryPointArray([point], resultFn);
    },
    queryPointArray: function(points, resultFn, validate) {
      var val = (validate !== undefined) ? validate : true;
      if (val) validatePointArray(points);
      var intervalArray = points.map(function(item) {
        return new Interval(item, item);
      });
      return _queryInterval(intervalArray, resultFn);
    },
    // options: endpoints, resultFn
    queryInterval: function(from, to, options) {
      validateInterval(from, to);
      return this.queryIntervalArray([from], [to], options);
    },
    // options: endpoints, resultFn, validate
    queryIntervalArray: function(from, to, options) {
      var intervalArray = [];
      var val = (options !== undefined && options.validate !== undefined) ? options.validate : true;
      var resFn = (options !== undefined && options.resultFn !== undefined) ? options.resultFn : undefined;
      var disjointFn = (options !== undefined && options.endpoints === false) ? Interval.prototype.disjointExcl : Interval.prototype.disjointIncl;
      if (val) validateIntervalArray(from, to);
      for(var i = 0; i < from.length; i++) {
        intervalArray.push(new Interval(from[i], to[i]));
      }
      return _queryInterval(intervalArray, resFn, disjointFn);
    },
    queryOverlap: function() {
      _queryOverlap(Interval.prototype.disjointIncl);
      return intervals;
    }
  }
}


text:
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else {
		var a = factory();
		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 1);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

function add(a, b){
  if (b === undefined) {
    return c => add(a, c)
  }

  return a + b
}

function adjust(fn, index, arr){
  if (index === undefined) {
    return (indexHolder, arrHolder) => adjust(fn, indexHolder, arrHolder)
  } else if (arr === undefined) {
    return holder => adjust(fn, index, holder)
  }

  return arr.map((val, key) => {
    if (key === index) {
      return fn(arr[ index ])
    }

    return val
  })
}

function any(fn, arr){
  if (arr === undefined) {
    return holder => any(fn, holder)
  }

  let counter = 0
  while (counter < arr.length) {
    if (fn(arr[ counter ])) {
      return true
    }
    counter++
  }

  return false
}

function append (val, arr) {
  if (arr === undefined) {
    return holder => append(val, holder)
  }
  const clone = arr
  clone.push(val)

  return clone
}

function isFunction(value){

  return typeof value === "function"
}

function compose () {
  const funcs = arguments
  let length = funcs.length

  while (length--) {
    if (!isFunction(funcs[ length ])) {
      throw new TypeError
    }
  }

  return function () {
    let args = arguments
    let len = funcs.length

    while (len--) {
      args = [ funcs[ len ].apply(this, args) ]
    }

    return args[ 0 ]
  }
}

function contains(val, arr) {
  if (arr === undefined) {
    return holder => contains(val, holder)
  }

  let index = -1
  let flag = false
  while (++index < arr.length && !flag) {
    if (equals(arr[ index ], val)) {
      flag = true
    }
  }

  return flag
}

function filter(fn, arr) {
  if (arr === undefined) {
    return holder => filter(fn, holder)
  }

  let index = -1
  let resIndex = 0
  const len =  arr.length
  const willReturn = []

  while (++index < len) {
    const value = arr[ index ]
    if (fn(value)) {
      willReturn[ resIndex++ ] = value
    }
  }

  return willReturn
}

function find(fn, arr){
  if (arr === undefined) {
    return holder => find(fn, holder)
  }

  return arr.find(fn)
}

function findIndex(fn, arr){
  if (arr === undefined) {
    return holder => findIndex(fn, holder)
  }

  const length = arr.length
  let index = -1

  while (++index < length) {
    if (fn(arr[ index ])) {
      return index
    }
  }

  return -1
}

function flatten(arr, willReturn){
  willReturn = willReturn === undefined ?
    [] :
    willReturn

  for (let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[ i ])) {
      flatten(arr[ i ], willReturn)
    } else {
      willReturn.push(arr[ i ])
    }
  }

  return willReturn
}

function drop(dropNumber, a){
  if (a === undefined) {
    return holder => drop(dropNumber, holder)
  }

  return a.slice(dropNumber)
}

function dropLast(dropNumber, a){
  if (a === undefined) {
    return holder => dropLast(dropNumber, holder)
  }

  return a.slice(0, -dropNumber)
}

function equals(a, b) {
  if (b === undefined) {

    return holder => equals(a, holder)
  } else if (a === b) {

    return a !== 0 || 1 / a === 1 / b
  }
  const aType = type(a)
  if (aType !== type(b)) {
    return false
  }

  if (aType === "Array") {
    const aClone = a
    const bClone = b

    return aClone.sort().toString() === bClone.sort().toString()
  }

  if (aType === "Object") {
    const aKeys = Object.keys(a)
    if (aKeys.length === Object.keys(b).length) {
      if (aKeys.length === 0) {
        return true
      }
      let flag = true
      aKeys.map(val => {
        if (flag) {
          const aValType = type(a[ val ])
          const bValType = type(b[ val ])
          if (aValType === bValType) {
            if (aValType === "Object") {
              if (Object.keys(a[ val ]).length === Object.keys(b[ val ]).length) {
                if (Object.keys(a[ val ]).length !== 0) {
                  if (!equals(a[ val ], b[ val ])) {
                    flag = false
                  }
                }
              } else {
                flag = false
              }
            } else if (!equals(a[ val ], b[ val ])) {
              flag = false
            }
          } else {
            flag = false
          }
        }
      })

      return flag
    }
  }

  return false
}

function head(a){
  if (typeof a === "string") {
    return a[ 0 ] || ""
  }

  return a[ 0 ]
}

function indexOf(question, arr) {
  if (arr === undefined) {
    return holder => indexOf(question, holder)
  }

  let index = -1
  const length = arr.length

  while (++index < length) {
    if (arr[ index ] === question) {
      return index
    }
  }

  return -1
}

function baseSlice(array, start, end) {
  let index = -1
  let length = array.length

  end = end > length ? length : end
  if (end < 0) {
    end += length
  }
  length = start > end ? 0 : end - start >>> 0
  start >>>= 0

  const result = Array(length)
  while (++index < length) {
    result[ index ] = array[ index + start ]
  }

  return result
}

function init(a){
  if (typeof a === "string") {
    return a.slice(0, -1)
  }

  return a.length ? baseSlice(a, 0, -1) : []
}

function join(glue, arr) {
  if (arr === undefined) {
    return holder => join(glue, holder)
  }

  return arr.join(glue)
}

function map(fn, arr) {
  if (arr === undefined) {
    return holder => map(fn, holder)
  }

  let index = -1
  const length = arr.length
  const willReturn = Array(length)

  while (++index < length) {
    willReturn[ index ] = fn(arr[ index ])
  }

  return willReturn
}

function last(a){
  if (typeof a === "string") {
    return a[ a.length - 1 ] || ""
  }

  return a[ a.length - 1 ]
}

function length(arr){

  return arr.length
}

function match(regex, str) {
  if (str === undefined) {
    return holder => match(regex, holder)
  }
  const willReturn = str.match(regex)

  return willReturn === null ?
    [] :
    willReturn
}

function merge(obj, newProps) {
  if (newProps === undefined) {
    return holder => merge(obj, holder)
  }

  return Object.assign({}, obj, newProps)
}

function omit(keys, obj){
  if (obj === undefined) {
    return holder => omit(keys, holder)
  }

  const willReturn = {}
  for (key in obj) {
    if (!keys.includes(key)) {
      willReturn[ key ] = obj[ key ]
    }
  }

  return willReturn
}

function path(pathArr, obj) {
  if (obj === undefined) {
    return holder => path(pathArr, holder)
  }

  let holder = obj
  let counter = 0
  while (counter < pathArr.length) {
    if (holder === null) {
      return undefined
    }
    holder = holder[ pathArr[ counter ] ]
    counter++
  }

  return holder
}

function pick(keys, obj) {
  if (obj === undefined) {
    return holder => pick(keys, holder)
  }
  const willReturn = {}
  let counter = 0
  while (counter < keys.length) {
    if (keys[ counter ] in obj) {
      willReturn[ keys[ counter ] ] = obj[ keys[ counter ] ]
    }
    counter++
  }

  return willReturn
}

function pluck(keyToPluck,arr){
  if(arr === undefined){
    return arrHolder => pluck(keyToPluck, arrHolder)
  }
  const willReturn = []
  map(
    val =>{
      if(!(val[keyToPluck]===undefined)){
        willReturn.push(val[keyToPluck])
      }
    },
    arr
  )
  return willReturn
}

function prepend(val, arr) {
  if (arr === undefined) {
    return holder => prepend(val, holder)
  }

  const clone = arr
  clone.unshift(val)

  return clone
}

function prop(key, obj) {
  if (obj === undefined) {
    return holder => prop(key, holder)
  }

  return obj[ key ]
}

function propEq(key, val, obj) {
  if (val === undefined) {
    return (valHolder, objHolder) => propEq(key, valHolder, objHolder)
  } else if (obj === undefined) {
    return holder => propEq(key, val, holder)
  }

  return obj[ key ] === val
}

function range(start, end) {
  const willReturn = []
  for (let i = start; i < end; i++) {
    willReturn.push(i)
  }

  return willReturn
}

function repeat(a, num) {
  if (num === undefined) {
    return holder => repeat(a, holder)
  }
  const willReturn = Array(num)

  return willReturn.fill(a)
}

function replace(regex, replacer, str) {
  if (replacer === undefined) {
    return (replacerHolder, strHolder) => replace(regex, replacerHolder, strHolder)
  } else if (str === undefined) {
    return holder => replace(regex, replacer, holder)
  }

  return str.replace(regex, replacer)
}

function subtract(a, b) {
  if (b === undefined) {
    return holder => subtract(a, holder)
  }

  return a - b
}

function sort(fn, arr) {
  if (arr === undefined) {
    return holder => sort(fn, holder)
  }
  const arrClone = Array.from(arr)

  return arrClone.sort(fn)
}

function sortBy(fn, arr) {
  if (arr === undefined) {
    return holder => sortBy(fn, holder)
  }
  const arrClone = Array.from(arr)

  return arrClone.sort((a, b) => {
    const fnA = fn(a)
    const fnB = fn(b)
    return fnA < fnB ?
      -1 :
      fnA > fnB ?
        1 :
        0
  })
}

function split(glue, str) {
  if (str === undefined) {
    return holder => split(glue, holder)
  }

  return str.split(glue)
}

function splitEvery(num, a) {
  if (a === undefined) {
    return holder => splitEvery(num, holder)
  }
  num = num > 1 ?
    num :
    1

  const willReturn = []
  let counter = 0
  while (counter < a.length) {
    willReturn.push(a.slice(counter, counter += num))
  }

  return willReturn
}

function tail(arr){

  return drop(1, arr)
}

function take(takeNumber, a) {
  if (a === undefined) {
    return holder => take(takeNumber, holder)
  } else if (typeof a === "string") {
    return a.slice(0, takeNumber)
  }

  return baseSlice(a, 0, takeNumber)
}

function takeLast(takeNumber, a) {
  if (a === undefined) {
    return holder => takeLast(takeNumber, holder)
  }
  const len = a.length
  takeNumber = takeNumber > len ?
    len :
    takeNumber

  if (typeof a === "string") {
    return a.slice(len - takeNumber)
  }
  takeNumber = len - takeNumber

  return baseSlice(a, takeNumber, len)
}

function toLower(str){

  return str.toLowerCase()
}

function toUpper(str){

  return str.toUpperCase()
}

function test(regex, str){
  if (str === undefined) {
    return holder => test(regex, holder)
  }

  return str.search(regex) === -1 ?
    false :
    true
}

function trim(str){

  return str.trim()
}

function type(a){
  if (a === null) {

    return "Null"
  } else if (Array.isArray(a)) {

    return "Array"
  } else if (typeof a === "boolean") {

    return "Boolean"
  } else if (typeof a === "number") {

    return "Number"
  } else if (typeof a === "string") {

    return "String"
  } else if (a === undefined) {

    return "Undefined"
  } else if (a instanceof RegExp) {

    return "RegExp"
  }

  const asStr = a.toString()
  if(asStr.startsWith("async")){
    return "Async"
  }else if(asStr.includes("function")||asStr.includes("=>")){
    return "Function"
  }

  return "Object"
}

function values(obj){
  const willReturn = []
  for (key in obj) {
    willReturn.push(obj[ key ])
  }

  return willReturn
}

function uniq(arr){
  let index = -1
  const willReturn = []
  while (++index < arr.length) {
    const value = arr[ index ]
    if (!contains(value, willReturn)) {
      willReturn.push(value)
    }
  }

  return willReturn
}

function update(index, newValue, arr){
  if (newValue === undefined) {
    return (newValueHolder, arrHolder) => update(index, newValueHolder, arrHolder)
  } else if (arr === undefined) {
    return holder => update(index, newValue, holder)
  }
  const arrClone = Array.from(arr)

  return arrClone.fill(newValue, index, index + 1)
}

function defaultTo(defaultArgument, inputArgument){
  if(arguments.length === 1){
    return inputArgumentHolder => defaultTo(defaultArgument,inputArgumentHolder)
  }
  return inputArgument === undefined || !(type(inputArgument)===type(defaultArgument)) ?
    defaultArgument :
    inputArgument
}

function curry(fn, inputArguments = {}) {
  return inputArgumentsHolder => {
    if (type(fn) === "Async") {
      return new Promise((resolve, reject) => {
        fn(merge(inputArgumentsHolder, inputArguments))
          .then(resolve)
          .catch(reject)
      })
    }
    return fn(merge(inputArgumentsHolder, inputArguments))
  }
}

exports.add = add
exports.adjust = adjust
exports.any = any
exports.append = append
exports.compose = compose
exports.contains = contains
exports.curry = curry
exports.defaultTo = defaultTo
exports.drop = drop
exports.dropLast = dropLast
exports.equals = equals
exports.filter = filter
exports.find = find
exports.findIndex = findIndex
exports.flatten = flatten
exports.head = head
exports.indexOf = indexOf
exports.init = init
exports.join = join
exports.last = last
exports.length = length
exports.map = map
exports.match = match
exports.merge = merge
exports.omit = omit
exports.path = path
exports.pick = pick
exports.pluck = pluck
exports.prepend = prepend
exports.prop = prop
exports.propEq = propEq
exports.range = range
exports.repeat = repeat
exports.replace = replace
exports.sort = sort
exports.sortBy = sortBy
exports.split = split
exports.splitEvery = splitEvery
exports.subtract = subtract
exports.tail = tail
exports.take = take
exports.takeLast = takeLast
exports.test = test
exports.toLower = toLower
exports.toUpper = toUpper
exports.trim = trim
exports.type = type
exports.uniq = uniq
exports.update = update
exports.values = values

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

const rambda = __webpack_require__(0)
module.exports.R = rambda

/***/ })
/******/ ]);
});


text:
package com.common.emotion.sql;

import android.database.Cursor;

import com.common.emotion.model.EmotionPackageModel;
import com.core.database.BaseDAO;
import com.core.database.Query;
import com.core.orm.ORMUtil;

public class Query_EmotionPackage extends Query {

	public Query_EmotionPackage(BaseDAO dao) {
		super(dao);
	}

	@Override
	public Object warpData(Cursor c) {
		if(c!=null&&c.getCount()>0){
			EmotionPackageModel model = new EmotionPackageModel();
			c.moveToFirst();
			ORMUtil.getInstance().ormQuery(EmotionPackageModel.class, model, c);
			return model;
		}
		return null;
	}

}