blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 7
332
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
50
| license_type
stringclasses 2
values | repo_name
stringlengths 7
115
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 557
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.85k
684M
⌀ | star_events_count
int64 0
77.7k
| fork_events_count
int64 0
48k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 82
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 7
5.41M
| extension
stringclasses 11
values | content
stringlengths 7
5.41M
| authors
listlengths 1
1
| author
stringlengths 0
161
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0ecbc87af9a97cf70daeb0ae193b5f5279a3c833
|
d5a27d789ebf1f9569ff3fb3c4a9c78ac74c82ea
|
/proj1a/ArrayDeque.java
|
dfd2703b11785316df68acf94f9089fe141c08ee
|
[] |
no_license
|
yuchengwto/cs61b_sp19
|
b600a88a4723b4a780445c33a14fb52267479865
|
7b8ab02146d876aea3b31a0ba178483e929e4800
|
refs/heads/master
| 2020-08-28T13:05:49.052516 | 2019-10-26T13:03:12 | 2019-10-26T13:03:12 | 217,708,339 | 7 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,718 |
java
|
public class ArrayDeque<item> {
private int size;
private int nextFirst;
private int nextLast;
private item[] items;
private static final int INIT_CAPACITY = 8;
private static final int RESIZE_FACTOR = 2;
private static final double MIN_USAGE = 0.25;
public void resize(int capacity){
item[] newArr = (item[]) new Object[capacity];
System.arraycopy(items, 0, newArr, 0, size);
items = newArr;
nextFirst = indexMinus(0);
nextLast = size;
}
public int indexPlus(int index){
return (++index) % items.length;
}
public int indexMinus(int index){
return (--index + items.length) % items.length;
}
public void addFrist(item item){
if (this.size == items.length)
this.resize(this.size * RESIZE_FACTOR);
items[nextFirst] = item;
nextFirst = indexMinus(nextFirst);
size++;
}
public void addLast(item item){
if (size == items.length)
resize(size * RESIZE_FACTOR);
items[nextLast] = item;
nextLast = indexPlus(nextLast);
size++;
}
public boolean isEmpty(){
if (this.size == 0){
return true;
} else {
return false;
}
}
public int size(){
return this.size;
}
public void printDeque(){
for (int i=indexPlus(nextFirst); i!=indexMinus(nextLast); i++)
System.out.print(items[i]+" ");
System.out.println(items[indexMinus(nextLast)]);
}
public item removeFirst(){
if (size == 0)
return null;
int p = indexPlus(nextFirst);
item value = items[p];
items[p] = null;
size--;
if (size < items.length*MIN_USAGE){
resize(items.length/RESIZE_FACTOR);
}
return value;
}
public item removeLast(){
if (size == 0)
return null;
int p = indexMinus(nextLast);
item value = items[p];
items[p] = null;
size--;
if (size < items.length*MIN_USAGE){
resize(items.length/RESIZE_FACTOR);
}
return value;
}
public item get(int index){
return items[index];
}
public ArrayDeque(){
this.items = (item[]) new Object[INIT_CAPACITY];
size = 0;
nextFirst = 4;
nextLast = 5;
}
public ArrayDeque(ArrayDeque<item> other){
this.items = (item[]) new Object[other.items.length];
this.size = other.size;
this.nextLast = other.nextLast;
this.nextFirst = other.nextFirst;
System.arraycopy(other.items, 0, this.items, 0, other.items.length);
}
}
|
[
"[email protected]"
] | |
34f2d321838e2f50925a7939c78f6ddf282f0626
|
c550c9ce8619f8b012dcffcc633aa70499c90b84
|
/Fragment/app/src/main/java/com/example/fragment/BeliFragment.java
|
9a1501869df5bea7736d50a50cf261abde59a1af
|
[] |
no_license
|
rokhis/WMA_Fragment
|
0adc60f2fc7d68015fdbbf7093c5db485fbe2c29
|
9b7300c192410b278fba770a04fe91a96e482dd4
|
refs/heads/main
| 2023-08-31T02:12:03.170040 | 2021-10-14T10:01:05 | 2021-10-14T10:01:05 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,023 |
java
|
package com.example.fragment;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link BeliFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class BeliFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public BeliFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment BeliFragment.
*/
// TODO: Rename and change types and number of parameters
public static BeliFragment newInstance(String param1, String param2) {
BeliFragment fragment = new BeliFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_beli, container, false);
}
}
|
[
"[email protected]"
] | |
40089cfe205829da047b2575cb7efcad6f1b4355
|
4d066b69651c90d3757da67ce5358614f6ddb92d
|
/src/com/raphfrk/bukkit/serverportcore/SPItemStack.java
|
176a7e0bfb8805882f161b7c828a22832129d50f
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
Raphfrk/Server-Port-Core
|
07ff07b334e65d446a71c63bfbe74d455a09cf5c
|
3bc65d056d2e2e931acfb471b87d6fa4ab12faa2
|
refs/heads/master
| 2020-04-06T18:35:46.931172 | 2012-01-12T02:36:53 | 2012-01-12T02:37:34 | 1,657,545 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 6,614 |
java
|
/*******************************************************************************
* Copyright (C) 2012 Raphfrk
*
* 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.
******************************************************************************/
package com.raphfrk.bukkit.serverportcore;
import java.io.Serializable;
import java.util.ArrayList;
import javax.persistence.Entity;
import javax.persistence.Id;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
@Entity
public class SPItemStack implements Serializable {
private static final long serialVersionUID = 1L;
public SPItemStack() {
}
public SPItemStack(String playerName, boolean armour, int slot, ItemStack itemStack) {
this.name = playerName;
this.armour = armour;
this.slot = slot;
setStack(itemStack);
}
@Id
private int id;
private String name;
private int typeId;
private int amount;
private short damage;
private int slot;
private boolean armour;
@Override
public String toString() {
return "[" + name + ": " + amount + " of " + typeId + " (" + damage + ") @" + slot + " (" + (armour?("ARMOUR)"):"MAIN)");
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setTypeId(int typeId) {
this.typeId = typeId;
}
public int getTypeId() {
return typeId;
}
public void setDamage(short damage) {
this.damage = damage;
}
public short getDamage() {
return damage;
}
public void setAmount(int amount) {
this.amount = amount;
}
public int getAmount() {
return amount;
}
public void setSlot(int slot) {
this.slot = slot;
}
public int getSlot() {
return slot;
}
public void setArmour(boolean armour) {
this.armour = armour;
}
public boolean isArmour() {
return armour;
}
public ItemStack getStack() {
if(typeId == 0) {
return null;
}
return new ItemStack(typeId, amount, damage);
}
public void setStack(ItemStack itemStack) {
if(itemStack == null) {
typeId = 0;
damage = 0;
amount = 0;
} else {
typeId = itemStack.getTypeId();
damage = itemStack.getDurability();
amount = itemStack.getAmount();
}
}
public void copy(SPItemStack itemStack) {
this.name = itemStack.getName();
setStack(itemStack.getStack());
}
public static SPItemStack[] getInventory(Player player) {
String playerName = player.getName();
PlayerInventory inv = player.getInventory();
ItemStack[] main = inv.getContents();
ItemStack[] armour = inv.getArmorContents();
ArrayList<SPItemStack> itemStacks = new ArrayList<SPItemStack>();
for(int cnt=0;cnt<main.length;cnt++) {
if(main[cnt] != null && main[cnt].getTypeId() != 0) {
itemStacks.add(new SPItemStack(playerName, false, cnt, main[cnt]));
}
}
for(int cnt=0;cnt<armour.length;cnt++) {
if(armour[cnt] != null && armour[cnt].getTypeId() != 0) {
itemStacks.add(new SPItemStack(playerName, true, cnt, armour[cnt]));
}
}
inv.clear();
return itemStacks.toArray(new SPItemStack[0]);
}
public static ItemStack getItemStack(PlayerInventory playerInventory, boolean armour, int slot) {
if(armour) {
if(slot==0) {
return playerInventory.getBoots();
} else if(slot==1) {
return playerInventory.getLeggings();
} else if(slot==2) {
return playerInventory.getChestplate();
} else if(slot==3) {
return playerInventory.getHelmet();
}
} else {
ItemStack[] main = playerInventory.getContents();
if(slot<0 || slot>=main.length) {
return null;
}
return main[slot];
}
return null;
}
final static ItemStack blankArmour = new ItemStack(0, 0, (short)0);
public static void setItemStack(PlayerInventory playerInventory, ItemStack itemStack, boolean armour, int slot) {
boolean clear = itemStack == null || itemStack.getTypeId() == 0;
ItemStack armourSetting = clear?blankArmour:itemStack;
if(armour && !clear) {
if(slot==0) {
playerInventory.setBoots(armourSetting);
} else if(slot==1) {
playerInventory.setLeggings(armourSetting);
} else if(slot==2) {
playerInventory.setChestplate(armourSetting);
} else if(slot==3) {
playerInventory.setHelmet(armourSetting);
}
} else {
if(armour) { // Hack grr
slot += playerInventory.getSize();
}
if(clear) {
playerInventory.clear(slot);
} else {
playerInventory.setItem(slot, itemStack);
}
}
}
public static boolean addItemStack(Player player, SPItemStack stack) {
if(stack == null || player == null) {
return false;
}
PlayerInventory inv = player.getInventory();
ItemStack current = getItemStack(inv, stack.isArmour(), stack.getSlot());
if(current == null || current.getTypeId()==0) {
setItemStack(inv, stack.getStack(), stack.isArmour(), stack.getSlot());
return true;
}
return false;
}
public static SPItemStack[] addInventory(Player player, SPItemStack[] stacks) {
ArrayList<SPItemStack> itemStacks = new ArrayList<SPItemStack>(stacks.length);
for(int cnt=0;cnt<stacks.length;cnt++) {
if(!addItemStack(player, stacks[cnt])) {
itemStacks.add(stacks[cnt]);
}
}
return itemStacks.toArray(stacks);
}
}
|
[
"[email protected]"
] | |
b447380b1f862f316913092ba77dc38c391e6311
|
57e451b7a1338dc26016fe9fb32abd512e99ccfb
|
/src/main/java/com/stocks/livermor/entity/LivermorSingleCompany.java
|
84c4fcaa1da922e6c2dc357dce5f69cbef5f95fe
|
[] |
no_license
|
IvanNikolaychuk/expert-octo-parakeet
|
ee13a743fc09d7183c8eb69973fff53ba08e267c
|
d765c89c3944d33ded74b597ee81c8585960439c
|
refs/heads/master
| 2021-01-09T05:36:26.820287 | 2017-09-22T04:37:34 | 2017-09-22T04:37:34 | 80,801,688 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 449 |
java
|
package com.stocks.livermor.entity;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity(name = "livermor_single_pair")
@Data
public class LivermorSingleCompany {
@Id
@GeneratedValue
private int id;
private String ticker;
public LivermorSingleCompany() {}
public LivermorSingleCompany(String ticker) {
this.ticker = ticker;
}
}
|
[
"[email protected]"
] | |
a5037b7f2f0462f2fee0544120b5564baeae96ea
|
0fd351d090fddfda0256b6aa7f1e3b08aea48a00
|
/app/src/androidTest/java/com/example/administrator/myapplication21/ApplicationTest.java
|
5a6014b1a1f906e8cb84789a50e796aa4bd49e63
|
[] |
no_license
|
fengminchao/GetInfo
|
2a5b3e8f375dbcf1917f39a68d45d9eaca83d4b5
|
318ddbb92892ebe3d9f3957344079c5fef131a93
|
refs/heads/master
| 2021-01-10T12:12:08.131196 | 2015-11-29T02:14:51 | 2015-11-29T02:14:51 | 47,046,667 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 384 |
java
|
package com.example.administrator.myapplication21;
import android.app.Application;
import android.test.ApplicationTestCase;
/**
* <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>
*/
public class ApplicationTest extends ApplicationTestCase<Application> {
public ApplicationTest() {
super(Application.class);
}
}
|
[
"[email protected]"
] | |
9d2cb50054d5c50f97c17d58540d22365dc21602
|
6e8c7dbccaa00d88c4a1dd660846412e262ea4ca
|
/app/src/main/java/com/baidu/mapapi/clusterutil/clustering/view/DefaultClusterRenderer.java
|
115158879cae60c42dabd6001cc093300c35849f
|
[] |
no_license
|
xuanyongcang/nwuasf1
|
3efd7393c77a640f260486024c29d4b4a05b7604
|
439200f5bd2c40a739cbd353b5fc6fe6241792e1
|
refs/heads/master
| 2021-01-19T02:32:44.989472 | 2016-08-05T07:04:19 | 2016-08-05T07:05:05 | 54,938,788 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 35,406 |
java
|
/*
* Copyright (C) 2015 Baidu, Inc. All Rights Reserved.
*/
package com.baidu.mapapi.clusterutil.clustering.view;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.TimeInterpolator;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.LayerDrawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.OvalShape;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;
import android.util.SparseArray;
import android.view.ViewGroup;
import android.view.animation.DecelerateInterpolator;
import com.baidu.mapapi.clusterutil.MarkerManager;
import com.baidu.mapapi.clusterutil.clustering.Cluster;
import com.baidu.mapapi.clusterutil.clustering.ClusterItem;
import com.baidu.mapapi.clusterutil.clustering.ClusterManager;
import com.baidu.mapapi.clusterutil.projection.Point;
import com.baidu.mapapi.clusterutil.projection.SphericalMercatorProjection;
import com.baidu.mapapi.clusterutil.ui.IconGenerator;
import com.baidu.mapapi.map.BaiduMap;
import com.baidu.mapapi.map.BitmapDescriptor;
import com.baidu.mapapi.map.BitmapDescriptorFactory;
import com.baidu.mapapi.map.Marker;
import com.baidu.mapapi.map.MarkerOptions;
import com.baidu.mapapi.map.Projection;
import com.baidu.mapapi.model.LatLng;
import com.baidu.mapapi.model.LatLngBounds;
import com.cmdesign.hellonwsuaf.R;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import static com.baidu.mapapi.clusterutil.clustering.algo.NonHierarchicalDistanceBasedAlgorithm.MAX_DISTANCE_AT_ZOOM;
/**
* The default view for a ClusterManager. Markers are animated in and out of clusters.
*/
@SuppressLint("NewApi")
public class DefaultClusterRenderer<T extends ClusterItem> implements
com.baidu.mapapi.clusterutil.clustering.view.ClusterRenderer<T> {
private static final boolean SHOULD_ANIMATE = Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
private final BaiduMap mMap;
private final IconGenerator mIconGenerator;
private final ClusterManager<T> mClusterManager;
private final float mDensity;
private static final int[] BUCKETS = {10, 20, 50, 100, 200, 500, 1000};
private ShapeDrawable mColoredCircleBackground;
/**
* Markers that are currently on the map.
*/
private Set<MarkerWithPosition> mMarkers = Collections.newSetFromMap(
new ConcurrentHashMap<MarkerWithPosition, Boolean>());
/**
* Icons for each bucket.
*/
private SparseArray<BitmapDescriptor> mIcons = new SparseArray<BitmapDescriptor>();
/**
* Markers for single ClusterItems.
*/
private MarkerCache<T> mMarkerCache = new MarkerCache<T>();
/**
* If cluster size is less than this size, display individual markers.
*/
private static final int MIN_CLUSTER_SIZE = 4;
/**
* The currently displayed set of clusters.
*/
private Set<? extends Cluster<T>> mClusters;
/**
* Lookup between markers and the associated cluster.
*/
private Map<Marker, Cluster<T>> mMarkerToCluster = new HashMap<Marker, Cluster<T>>();
private Map<Cluster<T>, Marker> mClusterToMarker = new HashMap<Cluster<T>, Marker>();
/**
* The target zoom level for the current set of clusters.
*/
private float mZoom;
private final ViewModifier mViewModifier = new ViewModifier();
private ClusterManager.OnClusterClickListener<T> mClickListener;
private ClusterManager.OnClusterInfoWindowClickListener<T> mInfoWindowClickListener;
private ClusterManager.OnClusterItemClickListener<T> mItemClickListener;
private ClusterManager.OnClusterItemInfoWindowClickListener<T> mItemInfoWindowClickListener;
public DefaultClusterRenderer(Context context, BaiduMap map, ClusterManager<T> clusterManager) {
mMap = map;
mDensity = context.getResources().getDisplayMetrics().density;
mIconGenerator = new IconGenerator(context);
mIconGenerator.setContentView(makeSquareTextView(context));
mIconGenerator.setTextAppearance(R.style.ClusterIcon_TextAppearance);
mIconGenerator.setBackground(makeClusterBackground());
mClusterManager = clusterManager;
}
@Override
public void onAdd() {
mClusterManager.getMarkerCollection().setOnMarkerClickListener(new BaiduMap.OnMarkerClickListener() {
@Override
public boolean onMarkerClick(Marker marker) {
return mItemClickListener != null && mItemClickListener.onClusterItemClick(mMarkerCache.get(marker));
}
});
mClusterManager.getClusterMarkerCollection().setOnMarkerClickListener(new BaiduMap.OnMarkerClickListener() {
@Override
public boolean onMarkerClick(Marker marker) {
return mClickListener != null && mClickListener.onClusterClick(mMarkerToCluster.get(marker));
}
});
}
@Override
public void onRemove() {
mClusterManager.getMarkerCollection().setOnMarkerClickListener(null);
mClusterManager.getClusterMarkerCollection().setOnMarkerClickListener(null);
}
private LayerDrawable makeClusterBackground() {
mColoredCircleBackground = new ShapeDrawable(new OvalShape());
ShapeDrawable outline = new ShapeDrawable(new OvalShape());
outline.getPaint().setColor(0x80ffffff); // Transparent white.
LayerDrawable background = new LayerDrawable(new Drawable[]{outline, mColoredCircleBackground});
int strokeWidth = (int) (mDensity * 3);
background.setLayerInset(1, strokeWidth, strokeWidth, strokeWidth, strokeWidth);
return background;
}
private com.baidu.mapapi.clusterutil.ui.SquareTextView makeSquareTextView(Context context) {
com.baidu.mapapi.clusterutil.ui.SquareTextView squareTextView =
new com.baidu.mapapi.clusterutil.ui.SquareTextView(context);
ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
squareTextView.setLayoutParams(layoutParams);
squareTextView.setId(R.id.text);
int twelveDpi = (int) (12 * mDensity);
squareTextView.setPadding(twelveDpi, twelveDpi, twelveDpi, twelveDpi);
return squareTextView;
}
private int getColor(int clusterSize) {
final float hueRange = 220;
final float sizeRange = 300;
final float size = Math.min(clusterSize, sizeRange);
final float hue = (sizeRange - size) * (sizeRange - size) / (sizeRange * sizeRange) * hueRange;
return Color.HSVToColor(new float[]{
hue, 1f, .6f
});
}
protected String getClusterText(int bucket) {
if (bucket < BUCKETS[0]) {
return String.valueOf(bucket);
}
return String.valueOf(bucket) + "+";
}
/**
* Gets the "bucket" for a particular cluster. By default, uses the number of points within the
* cluster, bucketed to some set points.
*/
protected int getBucket(Cluster<T> cluster) {
int size = cluster.getSize();
if (size <= BUCKETS[0]) {
return size;
}
for (int i = 0; i < BUCKETS.length - 1; i++) {
if (size < BUCKETS[i + 1]) {
return BUCKETS[i];
}
}
return BUCKETS[BUCKETS.length - 1];
}
/**
* ViewModifier ensures only one re-rendering of the view occurs at a time, and schedules
* re-rendering, which is performed by the RenderTask.
*/
@SuppressLint("HandlerLeak")
private class ViewModifier extends Handler {
private static final int RUN_TASK = 0;
private static final int TASK_FINISHED = 1;
private boolean mViewModificationInProgress = false;
private RenderTask mNextClusters = null;
@Override
public void handleMessage(Message msg) {
if (msg.what == TASK_FINISHED) {
mViewModificationInProgress = false;
if (mNextClusters != null) {
// Run the task that was queued up.
sendEmptyMessage(RUN_TASK);
}
return;
}
removeMessages(RUN_TASK);
if (mViewModificationInProgress) {
// Busy - wait for the callback.
return;
}
if (mNextClusters == null) {
// Nothing to do.
return;
}
RenderTask renderTask;
synchronized (this) {
renderTask = mNextClusters;
mNextClusters = null;
mViewModificationInProgress = true;
}
renderTask.setCallback(new Runnable() {
@Override
public void run() {
sendEmptyMessage(TASK_FINISHED);
}
});
renderTask.setProjection(mMap.getProjection());
renderTask.setMapZoom(mMap.getMapStatus().zoom);
new Thread(renderTask).start();
}
public void queue(Set<? extends Cluster<T>> clusters) {
synchronized (this) {
// Overwrite any pending cluster tasks - we don't care about intermediate states.
mNextClusters = new RenderTask(clusters);
}
sendEmptyMessage(RUN_TASK);
}
}
/**
* Determine whether the cluster should be rendered as individual markers or a cluster.
*/
protected boolean shouldRenderAsCluster(Cluster<T> cluster) {
return cluster.getSize() > MIN_CLUSTER_SIZE;
}
/**
* Transforms the current view (represented by DefaultClusterRenderer.mClusters and DefaultClusterRenderer.mZoom) to a
* new zoom level and set of clusters.
* <p/>
* This must be run off the UI thread. Work is coordinated in the RenderTask, then queued up to
* be executed by a MarkerModifier.
* <p/>
* There are three stages for the render:
* <p/>
* 1. Markers are added to the map
* <p/>
* 2. Markers are animated to their final position
* <p/>
* 3. Any old markers are removed from the map
* <p/>
* When zooming in, markers are animated out from the nearest existing cluster. When zooming
* out, existing clusters are animated to the nearest new cluster.
*/
private class RenderTask implements Runnable {
final Set<? extends Cluster<T>> clusters;
private Runnable mCallback;
private Projection mProjection;
private SphericalMercatorProjection mSphericalMercatorProjection;
private float mMapZoom;
private RenderTask(Set<? extends Cluster<T>> clusters) {
this.clusters = clusters;
}
/**
* A callback to be run when all work has been completed.
*
* @param callback
*/
public void setCallback(Runnable callback) {
mCallback = callback;
}
public void setProjection(Projection projection) {
this.mProjection = projection;
}
public void setMapZoom(float zoom) {
this.mMapZoom = zoom;
this.mSphericalMercatorProjection =
new SphericalMercatorProjection(256 * Math.pow(2, Math.min(zoom, mZoom)));
}
@SuppressLint("NewApi")
public void run() {
if (clusters.equals(DefaultClusterRenderer.this.mClusters)) {
mCallback.run();
return;
}
final MarkerModifier markerModifier = new MarkerModifier();
final float zoom = mMapZoom;
final boolean zoomingIn = zoom > mZoom;
final float zoomDelta = zoom - mZoom;
final Set<MarkerWithPosition> markersToRemove = mMarkers;
final LatLngBounds visibleBounds = mMap.getMapStatus().bound;
// TODO: Add some padding, so that markers can animate in from off-screen.
// Find all of the existing clusters that are on-screen. These are candidates for
// markers to animate from.
List<Point> existingClustersOnScreen = null;
if (DefaultClusterRenderer.this.mClusters != null && SHOULD_ANIMATE) {
existingClustersOnScreen = new ArrayList<Point>();
for (Cluster<T> c : DefaultClusterRenderer.this.mClusters) {
if (shouldRenderAsCluster(c) && visibleBounds.contains(c.getPosition())) {
Point point = mSphericalMercatorProjection.toPoint(c.getPosition());
existingClustersOnScreen.add(point);
}
}
}
// Create the new markers and animate them to their new positions.
final Set<MarkerWithPosition> newMarkers = Collections.newSetFromMap(
new ConcurrentHashMap<MarkerWithPosition, Boolean>());
for (Cluster<T> c : clusters) {
boolean onScreen = visibleBounds.contains(c.getPosition());
if (zoomingIn && onScreen && SHOULD_ANIMATE) {
Point point = mSphericalMercatorProjection.toPoint(c.getPosition());
Point closest = findClosestCluster(existingClustersOnScreen, point);
if (closest != null) {
LatLng animateTo = mSphericalMercatorProjection.toLatLng(closest);
markerModifier.add(true, new CreateMarkerTask(c, newMarkers, animateTo));
} else {
markerModifier.add(true, new CreateMarkerTask(c, newMarkers, null));
}
} else {
markerModifier.add(onScreen, new CreateMarkerTask(c, newMarkers, null));
}
}
// Wait for all markers to be added.
markerModifier.waitUntilFree();
// Don't remove any markers that were just added. This is basically anything that had
// a hit in the MarkerCache.
markersToRemove.removeAll(newMarkers);
// Find all of the new clusters that were added on-screen. These are candidates for
// markers to animate from.
List<Point> newClustersOnScreen = null;
if (SHOULD_ANIMATE) {
newClustersOnScreen = new ArrayList<Point>();
for (Cluster<T> c : clusters) {
if (shouldRenderAsCluster(c) && visibleBounds.contains(c.getPosition())) {
Point p = mSphericalMercatorProjection.toPoint(c.getPosition());
newClustersOnScreen.add(p);
}
}
}
// Remove the old markers, animating them into clusters if zooming out.
for (final MarkerWithPosition marker : markersToRemove) {
boolean onScreen = visibleBounds.contains(marker.position);
// Don't animate when zooming out more than 3 zoom levels.
// TODO: drop animation based on speed of device & number of markers to animate.
if (!zoomingIn && zoomDelta > -3 && onScreen && SHOULD_ANIMATE) {
final Point point = mSphericalMercatorProjection.toPoint(marker.position);
final Point closest = findClosestCluster(newClustersOnScreen, point);
if (closest != null) {
LatLng animateTo = mSphericalMercatorProjection.toLatLng(closest);
markerModifier.animateThenRemove(marker, marker.position, animateTo);
} else {
markerModifier.remove(true, marker.marker);
}
} else {
markerModifier.remove(onScreen, marker.marker);
}
}
markerModifier.waitUntilFree();
mMarkers = newMarkers;
DefaultClusterRenderer.this.mClusters = clusters;
mZoom = zoom;
mCallback.run();
}
}
@Override
public void onClustersChanged(Set<? extends Cluster<T>> clusters) {
mViewModifier.queue(clusters);
}
@Override
public void setOnClusterClickListener(ClusterManager.OnClusterClickListener<T> listener) {
mClickListener = listener;
}
@Override
public void setOnClusterInfoWindowClickListener(ClusterManager
.OnClusterInfoWindowClickListener<T> listener) {
mInfoWindowClickListener = listener;
}
@Override
public void setOnClusterItemClickListener(ClusterManager.OnClusterItemClickListener<T> listener) {
mItemClickListener = listener;
}
@Override
public void setOnClusterItemInfoWindowClickListener(ClusterManager
.OnClusterItemInfoWindowClickListener<T> listener) {
mItemInfoWindowClickListener = listener;
}
private static double distanceSquared(Point a, Point b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
private static Point findClosestCluster(List<Point> markers, Point point) {
if (markers == null || markers.isEmpty()) {
return null;
}
// TODO: make this configurable.
double minDistSquared = MAX_DISTANCE_AT_ZOOM * MAX_DISTANCE_AT_ZOOM;
Point closest = null;
for (Point candidate : markers) {
double dist = distanceSquared(candidate, point);
if (dist < minDistSquared) {
closest = candidate;
minDistSquared = dist;
}
}
return closest;
}
/**
* Handles all markerWithPosition manipulations on the map. Work (such as adding, removing, or
* animating a markerWithPosition) is performed while trying not to block the rest of the app's
* UI.
*/
@SuppressLint("HandlerLeak")
private class MarkerModifier extends Handler implements MessageQueue.IdleHandler {
private static final int BLANK = 0;
private final Lock lock = new ReentrantLock();
private final Condition busyCondition = lock.newCondition();
private Queue<CreateMarkerTask> mCreateMarkerTasks = new LinkedList<CreateMarkerTask>();
private Queue<CreateMarkerTask> mOnScreenCreateMarkerTasks = new LinkedList<CreateMarkerTask>();
private Queue<Marker> mRemoveMarkerTasks = new LinkedList<Marker>();
private Queue<Marker> mOnScreenRemoveMarkerTasks = new LinkedList<Marker>();
private Queue<AnimationTask> mAnimationTasks = new LinkedList<AnimationTask>();
/**
* Whether the idle listener has been added to the UI thread's MessageQueue.
*/
private boolean mListenerAdded;
private MarkerModifier() {
super(Looper.getMainLooper());
}
/**
* Creates markers for a cluster some time in the future.
*
* @param priority whether this operation should have priority.
*/
public void add(boolean priority, CreateMarkerTask c) {
lock.lock();
sendEmptyMessage(BLANK);
if (priority) {
mOnScreenCreateMarkerTasks.add(c);
} else {
mCreateMarkerTasks.add(c);
}
lock.unlock();
}
/**
* Removes a markerWithPosition some time in the future.
*
* @param priority whether this operation should have priority.
* @param m the markerWithPosition to remove.
*/
public void remove(boolean priority, Marker m) {
lock.lock();
sendEmptyMessage(BLANK);
if (priority) {
mOnScreenRemoveMarkerTasks.add(m);
} else {
mRemoveMarkerTasks.add(m);
}
lock.unlock();
}
/**
* Animates a markerWithPosition some time in the future.
*
* @param marker the markerWithPosition to animate.
* @param from the position to animate from.
* @param to the position to animate to.
*/
public void animate(MarkerWithPosition marker, LatLng from, LatLng to) {
lock.lock();
mAnimationTasks.add(new AnimationTask(marker, from, to));
lock.unlock();
}
/**
* Animates a markerWithPosition some time in the future, and removes it when the animation
* is complete.
*
* @param marker the markerWithPosition to animate.
* @param from the position to animate from.
* @param to the position to animate to.
*/
public void animateThenRemove(MarkerWithPosition marker, LatLng from, LatLng to) {
lock.lock();
AnimationTask animationTask = new AnimationTask(marker, from, to);
animationTask.removeOnAnimationComplete(mClusterManager.getMarkerManager());
mAnimationTasks.add(animationTask);
lock.unlock();
}
@Override
public void handleMessage(Message msg) {
if (!mListenerAdded) {
Looper.myQueue().addIdleHandler(this);
mListenerAdded = true;
}
removeMessages(BLANK);
lock.lock();
try {
// Perform up to 10 tasks at once.
// Consider only performing 10 remove tasks, not adds and animations.
// Removes are relatively slow and are much better when batched.
for (int i = 0; i < 10; i++) {
performNextTask();
}
if (!isBusy()) {
mListenerAdded = false;
Looper.myQueue().removeIdleHandler(this);
// Signal any other threads that are waiting.
busyCondition.signalAll();
} else {
// Sometimes the idle queue may not be called - schedule up some work regardless
// of whether the UI thread is busy or not.
// TODO: try to remove this.
sendEmptyMessageDelayed(BLANK, 10);
}
} finally {
lock.unlock();
}
}
/**
* Perform the next task. Prioritise any on-screen work.
*/
private void performNextTask() {
if (!mOnScreenRemoveMarkerTasks.isEmpty()) {
removeMarker(mOnScreenRemoveMarkerTasks.poll());
} else if (!mAnimationTasks.isEmpty()) {
mAnimationTasks.poll().perform();
} else if (!mOnScreenCreateMarkerTasks.isEmpty()) {
mOnScreenCreateMarkerTasks.poll().perform(this);
} else if (!mCreateMarkerTasks.isEmpty()) {
mCreateMarkerTasks.poll().perform(this);
} else if (!mRemoveMarkerTasks.isEmpty()) {
removeMarker(mRemoveMarkerTasks.poll());
}
}
private void removeMarker(Marker m) {
Cluster<T> cluster = mMarkerToCluster.get(m);
mClusterToMarker.remove(cluster);
mMarkerCache.remove(m);
mMarkerToCluster.remove(m);
mClusterManager.getMarkerManager().remove(m);
}
/**
* @return true if there is still work to be processed.
*/
public boolean isBusy() {
try {
lock.lock();
return !(mCreateMarkerTasks.isEmpty() && mOnScreenCreateMarkerTasks.isEmpty()
&& mOnScreenRemoveMarkerTasks.isEmpty() && mRemoveMarkerTasks.isEmpty()
&& mAnimationTasks.isEmpty());
} finally {
lock.unlock();
}
}
/**
* Blocks the calling thread until all work has been processed.
*/
public void waitUntilFree() {
while (isBusy()) {
// Sometimes the idle queue may not be called - schedule up some work regardless
// of whether the UI thread is busy or not.
// TODO: try to remove this.
sendEmptyMessage(BLANK);
lock.lock();
try {
if (isBusy()) {
busyCondition.await();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
@Override
public boolean queueIdle() {
// When the UI is not busy, schedule some work.
sendEmptyMessage(BLANK);
return true;
}
}
/**
* A cache of markers representing individual ClusterItems.
*/
private static class MarkerCache<T> {
private Map<T, Marker> mCache = new HashMap<T, Marker>();
private Map<Marker, T> mCacheReverse = new HashMap<Marker, T>();
public Marker get(T item) {
return mCache.get(item);
}
public T get(Marker m) {
return mCacheReverse.get(m);
}
public void put(T item, Marker m) {
mCache.put(item, m);
mCacheReverse.put(m, item);
}
public void remove(Marker m) {
T item = mCacheReverse.get(m);
mCacheReverse.remove(m);
mCache.remove(item);
}
}
/**
* Called before the marker for a ClusterItem is added to the map.
*/
protected void onBeforeClusterItemRendered(T item, MarkerOptions markerOptions) {
}
/**
* Called before the marker for a Cluster is added to the map.
* The default implementation draws a circle with a rough count of the number of items.
*/
protected void onBeforeClusterRendered(Cluster<T> cluster, MarkerOptions markerOptions) {
int bucket = getBucket(cluster);
BitmapDescriptor descriptor = mIcons.get(bucket);
if (descriptor == null) {
mColoredCircleBackground.getPaint().setColor(getColor(bucket));
descriptor = BitmapDescriptorFactory.fromBitmap(mIconGenerator.makeIcon(getClusterText(bucket)));
mIcons.put(bucket, descriptor);
}
// TODO: consider adding anchor(.5, .5) (Individual markers will overlap more often)
markerOptions.icon(descriptor);
}
/**
* Called after the marker for a Cluster has been added to the map.
*/
protected void onClusterRendered(Cluster<T> cluster, Marker marker) {
}
/**
* Called after the marker for a ClusterItem has been added to the map.
*/
protected void onClusterItemRendered(T clusterItem, Marker marker) {
}
/**
* Get the marker from a ClusterItem
*
* @param clusterItem ClusterItem which you will obtain its marker
* @return a marker from a ClusterItem or null if it does not exists
*/
public Marker getMarker(T clusterItem) {
return mMarkerCache.get(clusterItem);
}
/**
* Get the marker from a Cluster
*
* @param cluster which you will obtain its marker
* @return a marker from a cluster or null if it does not exists
*/
public Marker getMarker(Cluster<T> cluster) {
return mClusterToMarker.get(cluster);
}
/**
* Get the ClusterItem from a marker
*
* @param marker which you will obtain its ClusterItem
* @return a ClusterItem from a marker or null if it does not exists
*/
public T getClusterItem(Marker marker) {
return mMarkerCache.get(marker);
}
/**
* Get the Cluster from a marker
*
* @param marker which you will obtain its Cluster
* @return a Cluster from a marker or null if it does not exists
*/
public Cluster<T> getCluster(Marker marker) {
return mMarkerToCluster.get(marker);
}
/**
* Creates markerWithPosition(s) for a particular cluster, animating it if necessary.
*/
private class CreateMarkerTask {
private final Cluster<T> cluster;
private final Set<MarkerWithPosition> newMarkers;
private final LatLng animateFrom;
/**
* @param c the cluster to render.
* @param markersAdded a collection of markers to append any created markers.
* @param animateFrom the location to animate the markerWithPosition from, or null if no
* animation is required.
*/
public CreateMarkerTask(Cluster<T> c, Set<MarkerWithPosition> markersAdded, LatLng animateFrom) {
this.cluster = c;
this.newMarkers = markersAdded;
this.animateFrom = animateFrom;
}
private void perform(MarkerModifier markerModifier) {
// Don't show small clusters. Render the markers inside, instead.
if (!shouldRenderAsCluster(cluster)) {
for (T item : cluster.getItems()) {
Marker marker = mMarkerCache.get(item);
MarkerWithPosition markerWithPosition;
if (marker == null) {
MarkerOptions markerOptions = new MarkerOptions();
if (animateFrom != null) {
markerOptions.position(animateFrom);
markerOptions.icon(item.getBitmapDescriptor());
} else {
markerOptions.position(item.getPosition());
markerOptions.icon(item.getBitmapDescriptor());
}
onBeforeClusterItemRendered(item, markerOptions);
marker = mClusterManager.getMarkerCollection().addMarker(markerOptions);
markerWithPosition = new MarkerWithPosition(marker);
mMarkerCache.put(item, marker);
if (animateFrom != null) {
markerModifier.animate(markerWithPosition, animateFrom, item.getPosition());
}
} else {
markerWithPosition = new MarkerWithPosition(marker);
}
onClusterItemRendered(item, marker);
newMarkers.add(markerWithPosition);
}
return;
}
MarkerOptions markerOptions = new MarkerOptions()
.position(animateFrom == null ? cluster.getPosition() : animateFrom);
onBeforeClusterRendered(cluster, markerOptions);
Marker marker = mClusterManager.getClusterMarkerCollection().addMarker(markerOptions);
mMarkerToCluster.put(marker, cluster);
mClusterToMarker.put(cluster, marker);
MarkerWithPosition markerWithPosition = new MarkerWithPosition(marker);
if (animateFrom != null) {
markerModifier.animate(markerWithPosition, animateFrom, cluster.getPosition());
}
onClusterRendered(cluster, marker);
newMarkers.add(markerWithPosition);
}
}
/**
* A Marker and its position. Marker.getPosition() must be called from the UI thread, so this
* object allows lookup from other threads.
*/
private static class MarkerWithPosition {
private final Marker marker;
private LatLng position;
private MarkerWithPosition(Marker marker) {
this.marker = marker;
position = marker.getPosition();
}
@Override
public boolean equals(Object other) {
if (other instanceof MarkerWithPosition) {
return marker.equals(((MarkerWithPosition) other).marker);
}
return false;
}
@Override
public int hashCode() {
return marker.hashCode();
}
}
private static final TimeInterpolator ANIMATION_INTERP = new DecelerateInterpolator();
/**
* Animates a markerWithPosition from one position to another. TODO: improve performance for
* slow devices (e.g. Nexus S).
*/
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
private class AnimationTask extends AnimatorListenerAdapter implements ValueAnimator.AnimatorUpdateListener {
private final MarkerWithPosition markerWithPosition;
private final Marker marker;
private final LatLng from;
private final LatLng to;
private boolean mRemoveOnComplete;
private MarkerManager mMarkerManager;
private AnimationTask(MarkerWithPosition markerWithPosition, LatLng from, LatLng to) {
this.markerWithPosition = markerWithPosition;
this.marker = markerWithPosition.marker;
this.from = from;
this.to = to;
}
public void perform() {
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 1);
valueAnimator.setInterpolator(ANIMATION_INTERP);
valueAnimator.addUpdateListener(this);
valueAnimator.addListener(this);
valueAnimator.start();
}
@Override
public void onAnimationEnd(Animator animation) {
if (mRemoveOnComplete) {
Cluster<T> cluster = mMarkerToCluster.get(marker);
mClusterToMarker.remove(cluster);
mMarkerCache.remove(marker);
mMarkerToCluster.remove(marker);
mMarkerManager.remove(marker);
}
markerWithPosition.position = to;
}
public void removeOnAnimationComplete(MarkerManager markerManager) {
mMarkerManager = markerManager;
mRemoveOnComplete = true;
}
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
float fraction = valueAnimator.getAnimatedFraction();
double lat = (to.latitude - from.latitude) * fraction + from.latitude;
double lngDelta = to.longitude - from.longitude;
// Take the shortest path across the 180th meridian.
if (Math.abs(lngDelta) > 180) {
lngDelta -= Math.signum(lngDelta) * 360;
}
double lng = lngDelta * fraction + from.longitude;
LatLng position = new LatLng(lat, lng);
marker.setPosition(position);
}
}
}
|
[
"[email protected]"
] | |
53357651ddc9bbb0144e0a93f2ee30b933f002cd
|
c6b98c88fc553e709f2fb6fa88c7893c21f47f30
|
/Exareme-Docker/src/exareme/exareme-utils/src/main/java/madgik/exareme/utils/histogram/score/MinimizeVarianceHistogramScore.java
|
25812ab21084eb5b5add11e47fa0790ef6969afa
|
[
"MIT"
] |
permissive
|
LSmyrnaios/exareme
|
f8a7db17a20958c53bebc25a8e1b4eab96a7570e
|
9b2b9360f0564d08fc76a56a7a750e2d1074ed4f
|
refs/heads/master
| 2022-12-01T07:34:13.667213 | 2020-11-03T11:32:09 | 2020-11-03T11:32:09 | 159,374,117 | 0 | 0 |
MIT
| 2018-11-27T17:30:47 | 2018-11-27T17:30:47 | null |
UTF-8
|
Java
| false | false | 936 |
java
|
/**
* Copyright MaDgIK Group 2010 - 2015.
*/
package madgik.exareme.utils.histogram.score;
import madgik.exareme.utils.association.Pair;
import madgik.exareme.utils.histogram.Bucket;
import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;
import java.util.LinkedList;
/**
* @author herald
*/
public class MinimizeVarianceHistogramScore implements HistogramScore {
public static MinimizeVarianceHistogramScore instance = new MinimizeVarianceHistogramScore();
public double getScore(LinkedList<Bucket> bucketList) {
DescriptiveStatistics stats = new DescriptiveStatistics();
for (Bucket b : bucketList) {
DescriptiveStatistics bs = new DescriptiveStatistics();
for (Pair<?, Double> d : b.data) {
bs.addValue(d.b);
}
stats.addValue(bs.getStandardDeviation());
}
return -stats.getStandardDeviation();
}
}
|
[
"[email protected]"
] | |
3c649a80e8a86a86171306de9ece2f1de5305056
|
5ed47419511ce4b62dc44c9df172f283b98597fb
|
/driver/src/main/java/org/neo4j/driver/internal/async/ProtocolUtil.java
|
c0a8569c5cc24a77374595bb6652253dfa2c96ff
|
[
"Apache-2.0"
] |
permissive
|
praveenag/neo4j-java-driver
|
8e0c3a88f3493a382bb2a71626b248208ff24f33
|
914facf2403087ae03157c68f4dd76023112d8eb
|
refs/heads/1.5
| 2021-01-01T06:36:38.509839 | 2017-10-19T22:18:09 | 2017-10-19T22:18:09 | 97,465,223 | 0 | 0 | null | 2017-07-17T10:40:23 | 2017-07-17T10:40:23 | null |
UTF-8
|
Java
| false | false | 2,214 |
java
|
/*
* Copyright (c) 2002-2017 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.neo4j.driver.internal.async;
import io.netty.buffer.ByteBuf;
import static io.netty.buffer.Unpooled.copyInt;
import static io.netty.buffer.Unpooled.copyShort;
import static io.netty.buffer.Unpooled.unreleasableBuffer;
public final class ProtocolUtil
{
public static final int HTTP = 1213486160; //== 0x48545450 == "HTTP"
public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017;
public static final int PROTOCOL_VERSION_1 = 1;
public static final int NO_PROTOCOL_VERSION = 0;
public static final int CHUNK_HEADER_SIZE_BYTES = 2;
public static final int DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = Short.MAX_VALUE / 2;
private static final ByteBuf HANDSHAKE_BUF = unreleasableBuffer( copyInt(
BOLT_MAGIC_PREAMBLE,
PROTOCOL_VERSION_1,
NO_PROTOCOL_VERSION,
NO_PROTOCOL_VERSION,
NO_PROTOCOL_VERSION ) ).asReadOnly();
private static final ByteBuf MESSAGE_BOUNDARY_BUF = unreleasableBuffer( copyShort( 0 ) ).asReadOnly();
private static final ByteBuf CHUNK_HEADER_PLACEHOLDER_BUF = unreleasableBuffer( copyShort( 0 ) ).asReadOnly();
private ProtocolUtil()
{
}
public static ByteBuf handshake()
{
return HANDSHAKE_BUF.duplicate();
}
public static ByteBuf messageBoundary()
{
return MESSAGE_BOUNDARY_BUF.duplicate();
}
public static ByteBuf chunkHeaderPlaceholder()
{
return CHUNK_HEADER_PLACEHOLDER_BUF.duplicate();
}
}
|
[
"[email protected]"
] | |
4529d50a229e61f337732903c89b878421d32da7
|
ca1beeaba34710f4f41d5048bf58a89c1b9d8d29
|
/chatak-dao/src/main/java/com/chatak/pg/acq/dao/repository/FraudBasicRepository.java
|
f3e8002d3e687933b693e72d25f8b5898cffee4f
|
[] |
no_license
|
itsbalamurali/test_build
|
f63796b78a050cc03e34527f56dd840e546b0102
|
11c491b17c5a2643e1400a23882ba82d6f3d8033
|
refs/heads/master
| 2020-04-02T21:16:11.430445 | 2018-06-19T04:14:38 | 2018-06-19T04:14:38 | 154,793,051 | 0 | 2 | null | 2018-10-26T07:15:38 | 2018-10-26T07:15:38 | null |
UTF-8
|
Java
| false | false | 417 |
java
|
package com.chatak.pg.acq.dao.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;
import com.chatak.pg.acq.dao.model.PGFraudBasic;
public interface FraudBasicRepository extends JpaRepository<PGFraudBasic,Long>,QueryDslPredicateExecutor<PGFraudBasic>{
public PGFraudBasic findByMerchantId(Long merchantId);
}
|
[
"[email protected]"
] | |
b6de49c58011ba29036b0c18c2c72c503fe37cbb
|
86e14bce714e578b1ea0a622ebb7372d8ca51cfe
|
/finance.ui.html/src/main/java/org/eclipse/scout/apps/helloworld/ui/html/UiServletFilter.java
|
f12df1ea08895500d426060f4727db45f25b0a64
|
[
"Apache-2.0"
] |
permissive
|
markash/threesixty-finance
|
ecc622f73eff84ad5a97dda3bd664bdceff67046
|
da911bc55241fc27e6d57680371e834996d6aea3
|
refs/heads/master
| 2020-08-28T09:56:28.490889 | 2019-11-14T19:27:01 | 2019-11-14T19:27:01 | 217,667,191 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,679 |
java
|
package org.eclipse.scout.apps.helloworld.ui.html;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.scout.rt.platform.BEANS;
import org.eclipse.scout.rt.platform.security.ConfigFileCredentialVerifier;
import org.eclipse.scout.rt.server.commons.authentication.DevelopmentAccessController;
import org.eclipse.scout.rt.server.commons.authentication.FormBasedAccessController;
import org.eclipse.scout.rt.server.commons.authentication.FormBasedAccessController.FormBasedAuthConfig;
import org.eclipse.scout.rt.server.commons.authentication.ServletFilterHelper;
import org.eclipse.scout.rt.server.commons.authentication.TrivialAccessController;
import org.eclipse.scout.rt.server.commons.authentication.TrivialAccessController.TrivialAuthConfig;
/**
* This is the main servlet filter for the HTML UI.
*
* @author mpash
*/
public class UiServletFilter implements Filter {
private TrivialAccessController m_trivialAccessController;
private FormBasedAccessController m_formBasedAccessController;
private DevelopmentAccessController m_developmentAccessController;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
m_trivialAccessController = BEANS.get(TrivialAccessController.class).init(new TrivialAuthConfig()
.withExclusionFilter(filterConfig.getInitParameter("filter-exclude")).withLoginPageInstalled(true));
m_formBasedAccessController = BEANS.get(FormBasedAccessController.class)
.init(new FormBasedAuthConfig().withCredentialVerifier(BEANS.get(ConfigFileCredentialVerifier.class)));
m_developmentAccessController = BEANS.get(DevelopmentAccessController.class).init();
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
final HttpServletRequest req = (HttpServletRequest) request;
final HttpServletResponse resp = (HttpServletResponse) response;
if (m_trivialAccessController.handle(req, resp, chain)) {
return;
}
if (m_formBasedAccessController.handle(req, resp, chain)) {
return;
}
if (m_developmentAccessController.handle(req, resp, chain)) {
return;
}
BEANS.get(ServletFilterHelper.class).forwardToLoginForm(req, resp);
}
@Override
public void destroy() {
m_developmentAccessController.destroy();
m_formBasedAccessController.destroy();
m_trivialAccessController.destroy();
}
}
|
[
"[email protected]"
] | |
2d00027fa80ed52cebab99fbc2e19cd866502691
|
97b600effb31dea7d8f1de44960722e414b6b7ac
|
/network/src/main/java/test/TCPClient.java
|
2ec3ba1337faf2b828c89b8833667aa751bb4a2c
|
[] |
no_license
|
wpdnjsgh01/javastudy
|
1c6fcb16f93df63752b87bb3688bc31546ace315
|
1a0ab7df3d966ac7ef3fd2ed7a536c51b5fbe387
|
refs/heads/master
| 2023-08-12T07:24:59.974089 | 2021-10-07T05:50:08 | 2021-10-07T05:50:08 | 403,562,041 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,125 |
java
|
package test;
import java.io.*;
import java.net.*;
public class TCPClient {
private static final String SERVER_IP = "127.0.0.1";
private static final int SERVER_PORT = 5000;
public static void main(String[] args) {
Socket socket = null;
try {
// 1. 소켓 생성
socket = new Socket();
int rcv = socket.getReceiveBufferSize();
int snd = socket.getSendBufferSize();
System.out.println(rcv + " : " + snd);
socket.setReceiveBufferSize(1024 * 10);
socket.setSendBufferSize(1024 * 10);
rcv = socket.getReceiveBufferSize();
snd = socket.getSendBufferSize();
System.out.println(rcv + " : " + snd);
socket.setTcpNoDelay(true);
// 2. 서버 연결
socket.connect(new InetSocketAddress(SERVER_IP, SERVER_PORT));
//InetSocketAddress
//이 클래스는 IP 소켓 주소 (IP 주소 + 포트 번호)를 구현합니다.
//또한 쌍 (호스트 이름 + 포트 번호) 일 수도 있습니다.이 경우 호스트 이름을 확인하려고 시도합니다.
//해결에 실패하면 주소는unresolved프록시를 통한 연결과 같은 일부 환경에서는 여전히 사용할 수 있습니다.
// 3. IO Stream 받아오기
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
// 4. 쓰기
String data = "Hello World";
os.write(data.getBytes("UTF-8"));
//getBytes == 인코딩 형식 바꾸기
// 5. 읽기
byte[] buffer = new byte[256];
int readByteCount = is.read(buffer); // blocking
if (readByteCount == -1) {
// 클라이언트가 정상적으로 종료(close() 호출)
System.out.println("[client] closed by server");
}
data = new String(buffer, 0, readByteCount, "UTF-8");
System.out.println("[client] received:" + data);
} catch (SocketException e) {
System.out.println("[client] suddenly closed by server");
} catch (IOException e) {
System.out.println("[client] error: " + e);
} finally {
try {
if (socket != null && socket.isClosed() == false) {
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
|
[
"[email protected]"
] | |
4b015f5f3a44df4e8b28bb1cf920eba648f34c9b
|
ec528ae33bf60e455c2da6010d4493669dfedb91
|
/src/main/java/com/se/apiserver/v1/multipartfile/infra/api/MultipartFileDownloadController.java
|
bdb428443848b1397716b514ac280235cceb4b7c
|
[] |
no_license
|
hwanfront/se_api_server
|
92120648b095b446ef5dd20c8b2d184145f8b615
|
800f28a2de08a99a4130eecd4b170a452629b8ed
|
refs/heads/main
| 2023-06-12T22:13:56.773651 | 2021-07-10T14:21:01 | 2021-07-10T14:21:01 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,232 |
java
|
package com.se.apiserver.v1.multipartfile.infra.api;
import io.swagger.annotations.Api;
import com.se.apiserver.v1.multipartfile.application.service.MultipartFileDownloadService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping(value = "multipart-file/download")
@Api(tags = "파일 다운로드")
public class MultipartFileDownloadController {
@Autowired
private MultipartFileDownloadService multipartFileDownloadService;
@GetMapping("/{saveName:.+}")
@ApiOperation("단일 파일 다운로드")
@ResponseStatus(value = HttpStatus.OK)
public ResponseEntity<Resource> downloadFile(@PathVariable String saveName) {
return multipartFileDownloadService.download(saveName);
}
}
|
[
"[email protected]"
] | |
119e30db67ea432bfc571268525ef3d0ce46dfc9
|
94e5880912d9d9f90dee123277261fd95156e387
|
/src/local/JPL/ch23/ex23_03/ArgExec2.java
|
a4f9cff8c58229fc5d6e4aba6d87fc7bd1ed0525
|
[] |
no_license
|
mikan/java-training-course
|
5135bc940061e2832ba8a743d41629e73db6bc74
|
c4a3528bfdc6308f548f069cfdd5966d0105b061
|
refs/heads/master
| 2021-01-09T20:52:08.314015 | 2014-08-02T16:12:28 | 2014-08-02T16:12:28 | 13,364,128 | 1 | 0 | null | 2020-01-28T19:11:53 | 2013-10-06T15:21:40 |
Java
|
UTF-8
|
Java
| false | false | 406 |
java
|
/*
* Copyright(C) 2014 Yutaka Kato
*/
package local.JPL.ch23.ex23_03;
import java.io.IOException;
public class ArgExec2 {
public static void main(String[] args) throws IOException {
Process proc = Runtime.getRuntime().exec(args);
ProcessUtil.plugTogether(System.in, proc.getOutputStream(), proc);
ProcessUtil.plugTogether(System.out, proc.getInputStream(), proc);
}
}
|
[
"[email protected]"
] | |
e9cab0f60bf60d95fecacf4b5c771ca8b0785931
|
0d4aeccbca6e6b429b5494745b396c3442ca74d6
|
/app/src/main/java/com/hsd/fsxasm/params/HeartBeatParams.java
|
e039629af874558ab14cac1ebc9a05b7b452f601
|
[] |
no_license
|
MaiKurakiTT/asmfsx
|
6fe41a420d779d24cb39fb55571e55b2134fd21a
|
f134d66b46369ae6a0f94cb827efc1cceba633cd
|
refs/heads/master
| 2021-06-05T22:15:54.747905 | 2016-10-07T09:23:47 | 2016-10-07T09:23:47 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 629 |
java
|
package com.hsd.fsxasm.params;
import org.xutils.http.RequestParams;
import com.alibaba.fastjson.JSONObject;
import com.hsd.fsxasm.domain.FriendCircleBean;
import com.hsd.fsxasm.domain.HeartBeatBean;
import com.hsd.fsxasm.global.Global;
import com.hsd.fsxasm.global.TempInfo;
import android.app.DownloadManager.Request;
public class HeartBeatParams extends RequestParams{
public HeartBeatParams() {
super(Global.GET_SAIDS);
this.setAsJsonContent(true);
HeartBeatBean bean = new HeartBeatBean();
bean.setUUID(TempInfo.findFirst.getUuid());
this.addBodyParameter("json",JSONObject.toJSONString(bean));
}
}
|
[
"[email protected]"
] | |
540c75555dcaa3901ed8dbaa164ec131b3360bee
|
74249c6e11a0c784d9670a98cf752b64a7507593
|
/src/main/java/com/cuder/web/AllowanceController.java
|
b90c975912bc1cd27166ec584a625424471f136b
|
[] |
no_license
|
HuyNguyen031099/hrm-api
|
b9c0716c2d19e7a4c298f469de5773edbca69390
|
6a73a17fede08bf59fee21fc4408ea0fc5e8adfb
|
refs/heads/master
| 2023-06-07T01:24:14.052966 | 2021-07-03T04:00:38 | 2021-07-03T04:00:38 | 382,520,130 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,576 |
java
|
package com.cuder.web;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.cuder.model.Allowance;
import com.cuder.service.AllowanceService;
@RestController
@CrossOrigin(value = "*")
@RequestMapping(value = "/allowance")
public class AllowanceController {
@Autowired
AllowanceService allowanceService;
@GetMapping
public List<Allowance> getAllowanceList() {
return allowanceService.getAllAllowance();
}
@GetMapping("/{id}")
public Allowance getById(@PathVariable Integer id) {
return allowanceService.findById(id);
}
@PostMapping
public Allowance createAllowance(@RequestBody Allowance allowance) {
return allowanceService.createAllowance(allowance);
}
@PutMapping("/{id}")
public Allowance updateAllowance(@RequestBody Allowance newT, @PathVariable Integer id) {
return allowanceService.updateAllowance(newT, id);
}
@DeleteMapping("/{id}")
public void deleteAllowance(@PathVariable Integer id) {
allowanceService.deleteAllowance(id);
}
}
|
[
"[email protected]"
] | |
a55b039a7574128858c2cb3129208efa7a8dea41
|
7a38e1f3bb461e6083c0cc664b8b3401c4ea5790
|
/oop1/ex1/oop/ex1/filters/GreaterThanFilter.java
|
5eb821820fc0d97a5db111b6d450a1326ae40071
|
[] |
no_license
|
oryonatan/OOP1
|
cd86b46a918d8c0ae1e5ab1a277a560fb8893cd1
|
0e0216dfdc061297fd8fed527cf849f1f732a02f
|
refs/heads/master
| 2021-01-23T07:20:42.787199 | 2012-04-23T22:51:40 | 2012-04-23T22:51:40 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 767 |
java
|
package oop.ex1.filters;
import java.io.File;
import java.io.FileFilter;
import oop.ex1.exceptions.BadParamException;
/**
* A filter that looks for files bigger then a given size.
*
* @author yonatan,yuli
*
*/
public class GreaterThanFilter extends FileSizeFilter implements FileFilter {
/**
* Constructor for the filter.
*
* @param numberString
* the size as string.
* @throws BadParamException
*/
public GreaterThanFilter(String numberString) throws BadParamException {
super(numberString);
}
/*
* (non-Javadoc)
*
* @see java.io.FileFilter#accept(java.io.File)
*/
@Override
public boolean accept(File pathname) {
return ((double)pathname.length()> size) ^ negative;
}
}
|
[
"[email protected]"
] | |
c56d22f2bd27ffa18b0a141ae08514e39aa67161
|
5e2b892c1cf71c39272b3a541fcfc0fc5849e8ae
|
/src/test/java/com/example/demo/DemoApplicationTests.java
|
087eb87d47ff05b3ec386c3a5a946d61a4127056
|
[] |
no_license
|
lonelycodingman/TestGit
|
61aaaeac027494282f9d7345ae132446c6666f87
|
4853a524023a702848737160a4ffda8c5ddf70b1
|
refs/heads/main
| 2023-06-03T04:14:10.612010 | 2021-06-21T14:41:08 | 2021-06-21T14:41:08 | 377,201,869 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,067 |
java
|
package com.example.demo;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.Base64Utils;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
@SpringBootTest
class DemoApplicationTests {
@Test
void contextLoads() {
System.out.println("Hello World");
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
SecureRandom secureRandom = new SecureRandom();
keyGenerator.init(128,secureRandom);
SecretKey secretKey = keyGenerator.generateKey();
byte[] encode = Base64Utils.encode(secretKey.getEncoded());
for (int i=0;i< encode.length;i++){
System.out.print(encode[i]);
}
System.out.println("Hello World");
System.out.println("Hello World1");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
}
|
[
"[email protected]"
] | |
7146fbb4167f358415d2c3698f6acc143ff4ef44
|
e0b570a7f7556cf386265d7abf13994189456c89
|
/src/main/java/concrrent/learning/MainThread.java
|
f293bc5a74a78b9014b501ac6571b4f5db7a8040
|
[] |
no_license
|
niuqinghua/java-concurrent-learning
|
3e5f14a6875556f11d7bb0833499e6c7e6969795
|
beb1812fe8671d879bbcaaebb308a6c93e5e71ec
|
refs/heads/master
| 2021-01-19T12:38:54.201275 | 2015-08-28T09:56:56 | 2015-08-28T09:56:56 | 40,429,972 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 218 |
java
|
package concrrent.learning;
/**
* Created by niuqinghua on 15/8/9.
*/
public class MainThread {
public static void main(String[] args) {
LiffOff liffOff = new LiffOff();
liffOff.run();
}
}
|
[
"[email protected]"
] | |
ff4e1734c6d64de7567a1a9c7ba288223a81cf70
|
da91e7e8fa5b41b527eb3565a56aa9d86e939d6b
|
/src/section_10_generics/generics/FootballPlayer.java
|
f41808c67f9f978f36b708023a8b01702cc75d20
|
[] |
no_license
|
acneuromancer/udemy-java-masterclass
|
2609328edfa5a28a83aa96b00dd116ff0fe6eaa9
|
38628e10832bd7a3f0cf1e6b5c0910a95e5238de
|
refs/heads/master
| 2020-06-03T16:04:13.326381 | 2019-11-22T22:30:17 | 2019-11-22T22:30:17 | 191,641,117 | 0 | 2 | null | null | null | null |
UTF-8
|
Java
| false | false | 156 |
java
|
package section_10_generics.generics;
public class FootballPlayer extends Player {
public FootballPlayer(String name) {
super(name);
}
}
|
[
"[email protected]"
] | |
e0de264e66bc926d515ac6d4a7f17f70a821a991
|
f709375cdd3bace3490acdf94522ecd71e158c14
|
/ACM/WorldFinals/y2001/C.java
|
0984b1b0ee79e8d9cd7de77298c3b314250c4eaa
|
[] |
no_license
|
jefferyyuan/Competition-Programming
|
eddd122c59a4752014337bb3ce7e7598f8166faf
|
b13d8a7c91f0ad3def29e536fcbe300536dbf08b
|
refs/heads/master
| 2021-01-15T17:03:05.912308 | 2011-01-30T06:55:09 | 2011-01-30T06:55:09 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,798 |
java
|
package ACM.WorldFinals.y2001;
import java.io.*;
import java.util.*;
import java.awt.*;
/* 2001 World Finals
* Problem C: Crossword Puzzle
* Type: Brute Force
* Difficulty Coding: 3
* Algorithmic Difficulty: 1
* Solution: The board is small so try putting words in by DFS until we find a match.
*/
public class C {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(new File("crossword.in"));
int trials = 0;
while (true){
if (trials > 0) System.out.println("");
trials++;
int totalslots = sc.nextInt();
if (totalslots == 0) break;
Slot[] slots = new Slot[totalslots];
for (int i = 0; i < totalslots; i++){
slots[i] = new Slot(sc.nextInt()-1, sc.nextInt()-1, sc.next().charAt(0));
}
for (int i = 0; i < totalslots; i++) {
for (int j = i + 1; j < totalslots; j++){
if (slots[i].dir == slots[j].dir){
if (slots[i].dir == 0){
if (slots[i].r != slots[j].r) continue;
int conf = 1010 - Math.abs(slots[i].c - slots[j].c);
slots[i].conflicts += conf;
slots[j].conflicts += conf;
}
else {
if (slots[i].c != slots[j].c) continue;
int conf = 1010 - Math.abs(slots[i].r - slots[j].r);
slots[i].conflicts += conf;
slots[j].conflicts += conf;
}
}
else {
if (slots[i].dir == 0) {
if (slots[i].c > slots[j].c || slots[i].r < slots[j].r) continue;
int conf = 1020 - (slots[i].r - slots[j].r) - (slots[j].c - slots[i].c);
slots[i].conflicts += conf;
slots[j].conflicts += conf;
}
else {
if (slots[i].r > slots[j].r || slots[i].c < slots[j].c) continue;
int conf = 1020 - (slots[i].c - slots[j].c) - (slots[j].r - slots[i].r);
slots[i].conflicts += conf;
slots[j].conflicts += conf;
}
}
}
}
Arrays.sort(slots);
ArrayList<String> words = new ArrayList<String>();
for (int i = 0; i < totalslots + 1; i++){
words.add(sc.next());
}
char[][] board = new char[10][10];
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++)
board[i][j] = ' ';
}
globalset = new HashSet<String>();
dfs(slots, 0, words, board);
if (globalset.size() == 0){
System.out.println("Trial " + trials + ": Impossible");
}
else {
System.out.print("Trial " + trials + ":");
for (String w : globalset){
System.out.print(" " + w);
}
System.out.println("");
}
} // end while
}
public static HashSet<String> globalset;
@SuppressWarnings("unchecked")
public static void dfs(Slot[] slots, int depth, ArrayList<String> words, char[][] board){
if (depth == slots.length){
globalset.add(words.get(0));
return;
}
Slot curr = slots[depth];
for (int i = 0; i < words.size(); i++){
String word = words.get(i);
if (match(curr.r, curr.c, board, word, curr.dir)){
ArrayList<Point> changed = fillBoard(curr.r, curr.c, board, word, curr.dir);
ArrayList<String> newwords = (ArrayList<String>) words.clone();
newwords.remove(word);
dfs(slots, depth+1, newwords, board);
for (Point p: changed){
board[p.x][p.y] = ' ';
}
}
}
}
public static void printBoard(char[][] board){
for (int k = 0 ; k < 10; k++){
for (int j =0 ; j < 10; j++)
System.out.print(board[k][j]);
System.out.println();
}
System.out.println("-----------");
}
public static boolean match (int r, int c, char[][] board, String word, int dir){
if (dir == 0){
// across
if (c + word.length() > board.length) return false;
for (int i = c; i < c + word.length(); i++){
if (board[r][i] != ' ' && board[r][i] != word.charAt(i-c))
return false;
}
return true;
}
else {
// down
if (r + word.length() > board.length) return false;
for (int i = r; i < r + word.length(); i++){
if (board[i][c] != ' ' && board[i][c] != word.charAt(i-r))
return false;
}
return true;
}
}
public static ArrayList<Point> fillBoard(int r, int c, char[][] board, String word, int dir){
ArrayList<Point> changed = new ArrayList<Point>();
if (dir == 0){
for (int i = c; i < c + word.length(); i++){
if (board[r][i] == ' '){
changed.add(new Point(r, i));
board[r][i] = word.charAt(i-c);
}
}
}
else {
for (int i = r; i < r + word.length(); i++){
if (board[i][c] == ' '){
changed.add(new Point(i, c));
board[i][c] = word.charAt(i-r);
}
}
}
return changed;
}
private static class Slot implements Comparable<Slot>{
int r, c, dir;
int conflicts = 0;
public Slot(int r, int c, char q) {
this.r = r;
this.c = c;
if (q == 'D') dir = 1; else dir = 0;
}
public int compareTo(Slot s){
return s.conflicts - conflicts;
}
}
}
|
[
"[email protected]"
] | |
1caf8cad2c3953d01b26b7848bbb8ebbcc37df03
|
572b4080c5f90aa00e5c35f5f10fc98ec921a7a7
|
/DiaphanumJSF/src/com/boxable/AbstractPageTemplate.java
|
018a6251261b658ecabffb642ba6af243ec7dc90
|
[
"MIT"
] |
permissive
|
tttodorov13/diaphanum
|
8a04adb9bce8bc5ce9c04b5b18a6a11168907c5a
|
1e4cb4525cd585e5ff03f7f85e2990b5865f8752
|
refs/heads/master
| 2021-01-19T03:00:23.038515 | 2016-06-05T12:37:29 | 2016-06-05T12:37:29 | 48,318,423 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,010 |
java
|
package com.boxable;
import java.io.IOException;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.graphics.image.PDImage;
import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
/**
* Created by dgautier on 3/18/2015.
*/
public abstract class AbstractPageTemplate extends PDPage {
protected abstract PDDocument getDocument();
protected abstract float yStart();
protected void addPicture(PDImageXObject ximage, float cursorX, float cursorY, int width, int height) throws IOException {
PDPageContentStream contentStream = new PDPageContentStream(getDocument(), this, true, false);
contentStream.drawImage(ximage, cursorX, cursorY, width, height);
contentStream.close();
}
protected PDImage loadPicture(String nameJPGFile) throws IOException {
return PDImageXObject.createFromFile(nameJPGFile, getDocument());
}
}
|
[
"[email protected]"
] | |
988d44090393f2dd8a57986cbc51bcd81ddf1427
|
f6d6136cecd16122fa9a515a4283f94abf6b50ac
|
/src/com/command/Command.java
|
95b0992ef0fa3e17037594909c5e0c24182c0eda
|
[] |
no_license
|
renshen052/FileSystemDOS
|
446fbbbb491f4400af47c872d46a58ce2d853991
|
d0dc41ded00ff6a1dd17a27ffafa86d41be859e3
|
refs/heads/master
| 2020-07-01T18:26:38.486116 | 2019-08-09T06:57:29 | 2019-08-09T06:57:29 | 201,255,083 | 1 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 780 |
java
|
package com.command;
import java.util.regex.Matcher;
/**
* @author h w j
* @time 2019年8月6日
* @instruction
* 命令
*/
public interface Command {
/**
* 命令未找到
*/
final int NOTFINDCOMMAND = -1;
/**
* 参数未找到
*/
final int NOTFINDSECONDE = -2;
/**
* 语法异常
*/
final int ERRORCOMMAND = -3;
/**
* 执行成功
*/
final int SUCCESS = 1;
/**
* 未完成
*/
final int UNDONE = 0;
/**
* 不可读
*/
final int DONTREAD = 2;
/**
* 执行出错
*/
final int ERROR = 3;
/**
* 不是目录
*/
final int NOTADIRECTORY = 4;
/**
* 执行命令
*/
int excute(String[] command);
/**
* 命令的帮助
*/
void help();
}
|
[
"[email protected]"
] | |
76a8b59c6f6488dc833a3dc958410f10c6409129
|
b8fd2779fbbeb41a1841f8090fb8e750b3cdde77
|
/app/src/main/java/jnorbury/jonahnorbury_pset5/AddGroceryItemActivity.java
|
17a14d81897f9342b6f9bc5416d75057222d5799
|
[] |
no_license
|
JNorbury/JonahNorbury-pset5
|
194d8db521f88601f63c47260aec0226e57c833c
|
91dd7f8e9ee9ca275a2fca7a7af629c6f36127e2
|
refs/heads/master
| 2020-06-17T17:04:00.393706 | 2016-12-06T11:36:34 | 2016-12-06T11:36:34 | 74,986,249 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,012 |
java
|
package jnorbury.jonahnorbury_pset5;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
public class AddGroceryItemActivity extends AppCompatActivity {
public ToDoListManager mlm;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_add_grocery_item);
}
public void saveNewItemData(View view) {
EditText et = (EditText) findViewById(R.id.NewItemNameET);
String newname = et.getText().toString();
String etw = findViewById(R.id.newWeightET).toString();
if (newname.matches("") || etw.isEmpty() || etw == null) {
Toast.makeText(this, "No name given", Toast.LENGTH_SHORT).show();
} else {
Double etwd = Double.parseDouble(etw);
GroceryItem newitem = new GroceryItem(newname, etwd);
}
}
}
|
[
"[email protected]"
] | |
71d0265c0c6a0e1e2fb63b0d5af1c44097ba6d95
|
d8fea750274bafad117cd5d7094a498b7bc9b10e
|
/src/p026GoodAssignment.java
|
ab452752076d964a25ca0e585d004ca103bd92ed
|
[] |
no_license
|
Yoshi-Koki/TeachYourselfJava
|
3e4324ab0d7e13782e1f448a936f822db6216c6f
|
8d09fa4aea7117541e48f60a8ab176747f8f68e0
|
refs/heads/master
| 2023-04-23T21:04:11.341971 | 2021-05-05T13:53:29 | 2021-05-05T13:53:29 | 361,933,516 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 148 |
java
|
public class p026GoodAssignment {
public static void main(String args[]) {
byte b;
int i = 127;
b = (byte)i;
System.out.println(b);
}
}
|
[
"[email protected]"
] | |
bf922bc86ba8e20e23f5413299b678c85d61d97b
|
a866b7d5b917a65a2d01f5b6f9f958d73ece8a70
|
/src/Day09_IfStatement/Breaks.java
|
cb2339e7f81f884415464d27c60dd0663c0155cd
|
[] |
no_license
|
OksanaGood/Summer2020_B20
|
d716d1a3113c901ec2c1318b8e78f4471854f380
|
1497c2a3e271606e0be7a53456c3b38402ba7d55
|
refs/heads/master
| 2022-12-13T12:14:42.140967 | 2020-08-25T20:05:56 | 2020-08-25T20:05:56 | 284,592,681 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 324 |
java
|
package Day09_IfStatement;
public class Breaks {
public static void main(String[] args) {
String itsBreakTime = "Yes";
if (itsBreakTime == "yes"){
System.out.println("Take 15 minutes of break");
}else{
System.out.println("Continue the class");
}
}
}
|
[
"[email protected]"
] | |
42e6a1faa4aff71eb459947e646cf5d1f68f269c
|
823e7cf19ee5f2c079405b60c13715a598d48aa4
|
/src/org/marketsuite/framework/market/ChangeInfo.java
|
225ca0f25a6f4acf0b2eda7f40c05f5f00a94c45
|
[] |
no_license
|
shorebird2016/market-suite
|
2836ba54944ce915c045f5d06389d5ac1749ccde
|
ecb245b917c725464a8cde160e1e94af05291fd1
|
refs/heads/master
| 2020-12-30T16:45:46.504672 | 2017-05-11T20:51:28 | 2017-05-11T20:51:28 | 91,022,492 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 569 |
java
|
package org.marketsuite.framework.market;
import java.util.Calendar;
public class ChangeInfo {
public ChangeInfo(int _index, int _from, int _to, Calendar _calendar) {
index = _index;
from = _from;
to = _to;
calendar = _calendar;
}
public int getIndex() { return index; }
public int getFrom() { return from; }
public int getTo() { return to; }
public Calendar getCalendar() { return calendar; }
private int index; //of quote array
private int from;
private int to;
private Calendar calendar;
}
|
[
"[email protected]"
] | |
b3538f432dba8b33897f4403964f2695dc4fe36d
|
7a49fec39a5dfc3ffb99341d8b52729b53f04162
|
/src/main/java/br/com/crescer/stone_board/repository/NoteRepository.java
|
169be1e505ede472fe4e526c1df84d8c9e5b1a28
|
[] |
no_license
|
StoneBoard/crescer_2017_2_stone_board
|
61906a0e3be8f375f48a4753d9d0d6ea2ffd699d
|
60b519ac7d897741aaf02803719493bf077e0ddb
|
refs/heads/master
| 2021-08-30T21:21:18.881432 | 2017-12-19T13:03:21 | 2017-12-19T13:03:21 | 114,755,085 | 0 | 0 | null | 2017-12-19T11:05:51 | 2017-12-19T11:05:50 | null |
UTF-8
|
Java
| false | false | 259 |
java
|
package br.com.crescer.stone_board.repository;
import br.com.crescer.stone_board.entity.Note;
import org.springframework.data.jpa.repository.JpaRepository;
/**
*
* @author willian
*/
public interface NoteRepository extends JpaRepository<Note, Long> {
}
|
[
"[email protected]"
] | |
d6314dce64d82c1fbb68126735dcb3a7cc0390ab
|
a599ccbe48bad09d6a51914fc3f79f600f5c96ec
|
/app/src/androidTest/java/com/example/robin/esp8266ledapp/ExampleInstrumentedTest.java
|
740fb807efcbf1074e949f5ec5b64c1c9c8886a8
|
[] |
no_license
|
lonnqvr1/androidstudioledcode
|
3ea8929a9f71042daa43d461b8035cc9d1856ec4
|
40b79572012da7d3293bcddc84151d8063005941
|
refs/heads/master
| 2021-01-13T16:00:44.641076 | 2017-01-24T08:13:27 | 2017-01-24T08:13:27 | 79,782,118 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 766 |
java
|
package com.example.robin.esp8266ledapp;
import android.content.Context;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumentation test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() throws Exception {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.example.robin.esp8266ledapp", appContext.getPackageName());
}
}
|
[
"[email protected]"
] | |
95f4d4b86a59778f8754ec2966602fc27ae48f4a
|
6b7b54c70cc3a6da985d36d002220a7c9dc2e33b
|
/bauer_defense2/src/main/java/de/propra/defense/Scarecrow.java
|
e61fdee80245805d57b91ce4b8ec12a99fa1bf47
|
[] |
no_license
|
MarvinHoppen/PU6Test
|
0e1b8acb334614054f353be63222273209813619
|
74eee1e301ab11526d33575292c270cfac765f17
|
refs/heads/main
| 2023-06-04T11:20:32.200750 | 2021-06-25T06:14:23 | 2021-06-25T06:14:23 | 380,140,939 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,819 |
java
|
package de.propra.defense;
import de.propra.defense.ui.GamePanel;
import java.util.Optional;
import java.util.Set;
public class Scarecrow implements Unit2 {
final String name = "Scarecrow";
private final GamePanel game;
private int row;
private int col;
private int delay;
private double full = 0;
private int hitpoints;
private final int strength;
public Scarecrow(GamePanel game,int row, int col) {
this.game = game;
this.row = row;
this.col = col;
this.hitpoints = 25;
this.strength = 3;
}
@Override
public void placeUnit(int row, int col) {
if (game.occupied(row, col)) return;
game.removeUnit(this.row, this.col);
game.placeUnit(UnitType.SCARECROW, row, col);
this.row = row;
this.col = col;
}
@Override
public String getName() {
return name;
}
@Override
public int getHitpoints() {
return hitpoints;
}
@Override
public int getRow() {
return row;
}
@Override
public int getCol() {
return col;
}
@Override
public boolean isStationary() {
return true;
}
@Override
public boolean isLivingPlant() {
return false;
}
@Override
public boolean isLivingBug() {
return false;
}
@Override
public boolean isLivingEnemy() {
return false;
}
@Override
public boolean isLivingCrow() {
return false;
}
// ACT-METHODE
@Override
public void act(Set<Unit2> units) {
Optional<Unit2> nearest =
units.stream().filter(Unit2::isLivingCrow).min((o1, o2) -> distance(this, o1, o2));
if (nearest.isPresent()) {
Unit2 crow = nearest.get();
if (isNeighbor(crow, 3)) {
attack(crow);
}
else {
if (delay == (int)full) {
delay = 0;
}
else {
delay++;
}
}
}
}
@Override
public void moveRandomly() {
placeUnit(randomWalk(row), randomWalk(col));
}
@Override
public void moveTowards(Unit2 other) {
int nextrow = row;
int nextcol = col;
if (row < other.getRow()) nextrow++;
if (row > other.getRow()) nextrow--;
if (col < other.getCol()) nextcol++;
if (col > other.getCol()) nextcol--;
placeUnit(nextrow, nextcol);
}
@Override
public int randomWalk(int r) {
if (Math.random() < 0.25) return r - 1;
if (Math.random() > 0.75) return r + 1;
return r;
}
@Override
public void attack(Unit2 other) {
other.hit(strength);
System.out
.println(name + " hits " + other.getName() + " Remaining Hitpoints: " + other.getHitpoints());
other.hit(strength);
}
@Override
public void hit(int strength) {
hitpoints -= strength;
}
@Override
public boolean isNeighbor(Unit2 other, int dist) {
return Math.abs(row - other.getRow()) <= dist &&
Math.abs(col - other.getCol()) <= dist;
}
@Override
public int distance(Unit2 me, Unit2 a, Unit2 b) {
var d1 = distance(me, a);
var d2 = distance(me, b);
return Double.compare(d1, d2);
}
@Override
public double distance(Unit2 me, Unit2 b) {
return Math.sqrt(square(me.getRow() - b.getRow()) + square(me.getCol() - b.getCol()));
}
@Override
public double square(int v) {
return v * v;
}
@Override
public boolean isDead() {
return hitpoints <= 0;
}
@Override
public boolean isAlive() {
return hitpoints > 0;
}
}
|
[
"[email protected]"
] | |
46c0b0b90d269c1ac2afc8d396f2aef9ef7e9cb8
|
7ea4ee138ebdc28ecaceca47b00972b9b5241d82
|
/home-works/src/main/java/com/sergey/prykhodko/example/shop/Product.java
|
2a60c1f46a5acf6fa4b392a5414361913ef32f5f
|
[] |
no_license
|
JimmyUA/advanced-java-home-works
|
ec40f89cac4ac5234e0c37f37594c65d44179dff
|
e949c99c8606e45477a7ae9bf3f36265d9872844
|
refs/heads/master
| 2020-12-02T10:04:33.130975 | 2017-08-10T09:44:52 | 2017-08-10T09:44:52 | 96,687,238 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 532 |
java
|
package com.sergey.prykhodko.example.shop;
/**
* Created by Sergey on 10.07.2017.
*/
public class Product {
private String name;
private long price;
public Product(String name, int price) {
this.name = name;
this.price =price;
}
public void setName(String name) {
this.name = name;
}
public void setPrice(long price) {
this.price = price;
}
public long getPrice() {
return price;
}
public String getName() {
return name;
}
}
|
[
"[email protected]"
] | |
1f392a144b6070c9ff90c586547bcdf07b4c8066
|
f695cb61d622846c48c59684182a68dc92d51315
|
/app/src/main/java/com/example/quizapp/ui/ScoreActivity.java
|
2c40881ff82664ca661f85edde0a4181736a4e57
|
[] |
no_license
|
Sanjeevkumar94/QuizApp
|
fe14db64a4bc81e7aaf170fb2cee49ec0facbfaf
|
fd6d86766a45b5f1305de08acc27e43c09e5e368
|
refs/heads/master
| 2023-01-20T14:12:59.645537 | 2020-11-28T14:22:35 | 2020-11-28T14:22:35 | 305,705,157 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,906 |
java
|
package com.example.quizapp.ui;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.AppCompatButton;
import androidx.appcompat.widget.AppCompatTextView;
import static com.example.quizapp.utils.CommonUtils.totalScore;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.example.quizapp.R;
public class ScoreActivity extends AppCompatActivity implements View.OnClickListener {
AppCompatTextView tv_score,tv_status;
AppCompatButton btn_retake;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_score);
tv_score = findViewById(R.id.tv_score);
tv_status = findViewById(R.id.tv_status);
btn_retake = findViewById(R.id.btn_retake);
btn_retake.setOnClickListener(this);
Log.d("ScoreActivity<<<",""+totalScore);
if(totalScore<=4){
tv_score.setText("Your Score is "+totalScore);
tv_status.setText("Please try again!");
btn_retake.setVisibility(View.VISIBLE);
}
else if(totalScore<=6){
tv_score.setText("Your Score is "+totalScore);
tv_status.setText("Good Job!");
}
else if(totalScore<=8){
tv_score.setText("Your Score is "+totalScore);
tv_status.setText("Excellent work!");
}
else if(totalScore<=10){
tv_score.setText("Your Score is "+totalScore);
tv_status.setText("You are genius!");
}
}
@Override
public void onClick(View v) {
startActivity(new Intent(this,MainQuizActivty.class));
finish();
totalScore=0;
}
@Override
public void onBackPressed() {
super.onBackPressed();
finishAffinity();
totalScore=0;
}
}
|
[
"[email protected]"
] | |
10363b991181ac21c24c1d7be81b6db728362a67
|
2f7ae903a24c5b882111de29ac74b68643388a66
|
/Auction/src/main/java/Models/Review.java
|
e1f37874a44c3880814b466764067529f25b8d30
|
[] |
no_license
|
LevanSamadashvili/final-project-empty-barrels
|
ba568ef3e8286f709b5f3d5abaf10b2ff56ded1f
|
2d60764d12257a72c9524006d0a68f811b2b0328
|
refs/heads/master
| 2023-07-05T18:20:35.135325 | 2021-08-16T08:48:36 | 2021-08-16T08:48:36 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,999 |
java
|
package Models;
import Helper.GeneralConstants;
public class Review implements GeneralConstants {
private int id;
private int reviewerId;
private int recipientId;
private int score;
private String review;
public Review(int id , int reviewerId , int recipientId , int score, String review) {
this.id = id;
this.reviewerId=reviewerId;
this.recipientId=recipientId;
this.score=score;
this.review=review;
}
public Review(int reviewerId , int recipientId , int score, String review) {
this (NO_ID,reviewerId,recipientId,score,review);
}
public int getId() {
return id;
}
public int getReviewerId() {
return reviewerId;
}
public int getRecipientId() {
return recipientId;
}
public int getScore() {
return score;
}
public String getReview() {
return review;
}
public void setId(int id) {
this.id=id;
}
public void setReviewerId(int reviewerId) {
this.reviewerId=reviewerId;
}
public void setRecipientId(int recipientId) {
this.recipientId=recipientId;
}
/**
@param score must be between 1 and 5, anything else is turned to -1
*/
public void setScore (int score) {
if (1<=score && score<=5) {
this.score = score;
}else{
this.score=-1;
}
}
public void setReview(String review) {
this.review=review;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Review currentReview = (Review) o;
return (id == currentReview.getId()
&& reviewerId == currentReview.getReviewerId()
&& recipientId == currentReview.getRecipientId()
&& score == currentReview.getScore()
&& review.equals(currentReview.getReview()));
}
}
|
[
"[email protected]"
] | |
c58949fdfa4237898b45e84392d360016a0f027b
|
6fe0e35a0305e5e5cb29e65803a707374e2c1db4
|
/src/cn/etc/Dao/OrderListDao.java
|
bfc80b0f99b26905ceed3ceecad047894162b89c
|
[] |
no_license
|
bai199/Project_Food
|
0f7d3184e41ad6298c913bfee250cbd3d1fa9aa9
|
f9a8b0732e14a3e4ea078fa3226ec256ba6999fe
|
refs/heads/master
| 2021-08-19T06:40:26.058552 | 2017-11-24T00:39:29 | 2017-11-24T00:39:29 | 111,860,453 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 268 |
java
|
package cn.etc.Dao;
import java.util.List;
import cn.etc.Model.OrderList;
public interface OrderListDao {
public List<OrderList> searchByOrder(OrderList orderList);
public int addOrderList(OrderList orderList);
public int deleteOrderList(OrderList orderList);
}
|
[
"[email protected]"
] | |
8b3660e0507e2ae64c1cf56581b87d315e239184
|
ba5d6d8d578848a224aab689af9217399304e007
|
/demo/src/main/java/com/kristal/demo/repository/RoleRepository.java
|
a859d0f7510a8cfab303e6dc0f0981e3b78614ce
|
[] |
no_license
|
mail2mdfaisal/demo
|
640f26964d47cbeb6316833990684e7624eb2758
|
9b0137ed3de0c8ab1f400ae4acfea2e347529dda
|
refs/heads/master
| 2020-12-13T18:38:25.107461 | 2020-01-17T07:45:53 | 2020-01-17T07:45:53 | 234,497,130 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 272 |
java
|
package com.kristal.demo.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.kristal.demo.model.Role;
@Repository
public interface RoleRepository extends JpaRepository<Role,Long> {
}
|
[
"[email protected]"
] | |
8147ba546934cb85df36f0588f76155342e87314
|
e7d64fd1dc3a8c6b76ccbc08027c0bb36b874273
|
/test/helloworldapp/BuildPostOfficeIITest.java
|
89e8b65877aca2a260f60159fd61af5a7223613b
|
[] |
no_license
|
zhongxun/lintcodeladder
|
ed2d3c77389b4ad016f7599331d087eaa9541d0e
|
9c07419d0332fcc07e1b182a260aab7add86f4cc
|
refs/heads/master
| 2020-05-22T00:03:22.381711 | 2017-06-05T03:19:01 | 2017-06-05T03:19:01 | 64,240,705 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 992 |
java
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package helloworldapp;
import org.junit.Test;
import static org.junit.Assert.*;
/**
*
* @author v-xuzhon
*/
public class BuildPostOfficeIITest {
public BuildPostOfficeIITest() {
}
/**
* Test of shortestDistance method, of class BuildPostOfficeII.
*/
@Test
public void testShortestDistance() {
System.out.println("shortestDistance");
int[][] grid = {{0,1,0,0,0},{1,0,0,2,1},{0,1,0,0,0}};
BuildPostOfficeII instance = new BuildPostOfficeII();
int expResult = 8;
int result = instance.shortestDistance(grid);
assertEquals(expResult, result);
// TODO review the generated test code and remove the default call to fail.
fail("The test case is a prototype.");
}
}
|
[
"[email protected]"
] | |
316cc648e9df30ff8d6728a29d2958b9ffdf63be
|
05fdd5cb8cc8ecd070723d8179e11ab1a8e6e52e
|
/app/src/main/java/com/example/covidvaccination/Adapters/DatePickerFragment.java
|
d4cd4edb9236d08b23e0ba6d14dff61da9236312
|
[] |
no_license
|
Priyadarshan2000/Covid19-Vaccination-Availability
|
555d7e0f01b94b7c51e5e40cfb37d8ed6d79911d
|
5477cc329404d6a57371c338e9d2e18cba0b6f2c
|
refs/heads/main
| 2023-05-07T01:21:36.623955 | 2021-06-02T06:15:53 | 2021-06-02T06:15:53 | 372,290,133 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 734 |
java
|
package com.example.covidvaccination.Adapters;
import android.app.DatePickerDialog;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.DialogFragment;
import java.util.Calendar;
public class DatePickerFragment extends DialogFragment {
@NonNull
@Override
public DatePickerDialog onCreateDialog(@Nullable Bundle savedInstanceState) {
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
return new DatePickerDialog(getActivity(), (DatePickerDialog.OnDateSetListener) getActivity(), year, month, day);
}
}
|
[
"[email protected]"
] | |
cb1045b6a666b95e25cf7c54d3274bc555c1b0d3
|
3b9c52f683ba0c0193a570fc7c6103a94965ed9b
|
/Week09/ReverseOnlyLetters.java
|
f83b7f010c6076d4a57e248deb18e35a1e335fc2
|
[] |
no_license
|
JennyJenny00/algorithm010
|
24bdce0b505b65541d59d4b59502fc6039034841
|
0a1d126fb35a46121a04f1df39745efbbe4b3000
|
refs/heads/master
| 2023-02-06T10:39:33.840672 | 2020-12-28T06:25:30 | 2020-12-28T06:25:30 | 270,489,056 | 0 | 0 | null | 2020-06-08T01:42:52 | 2020-06-08T01:42:51 | null |
UTF-8
|
Java
| false | false | 674 |
java
|
public class ReverseOnlyLetters {
public String reverseOnlyLetters(String S) {
if (S == null || S.length() == 0);
int left = 0;
int right = S.length() - 1;
char[] arr = S.toCharArray();
while (left < right) {
if (Character.isLetter(arr[left]) && Character.isLetter(arr[right])) {
char tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
if (!Character.isLetter(arr[left])) left++;
if (!Character.isLetter(arr[right])) right--;
}
return new String(arr);
}
}
|
[
"[email protected]"
] | |
a853344fb08b6b8081099e6b8a8fdc5dbe23ccd5
|
00e8fa14dcbdcc7ad81ce1cd905ad87c04c22c8b
|
/sources/org/andengine/util/modifier/ease/EaseExponentialInOut.java
|
9099384247ce59f3b487f923dca2c5d216b67db9
|
[] |
no_license
|
Dovydove/GodGameTranslation
|
ec4c1f793875089e0355cf2fba4cad82c237dd2b
|
0715105526eb606f932e3956e14a26fe20cd033a
|
refs/heads/master
| 2021-05-24T07:42:04.453572 | 2020-04-07T13:50:05 | 2020-04-07T13:50:05 | 253,454,454 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 720 |
java
|
package org.andengine.util.modifier.ease;
public class EaseExponentialInOut implements IEaseFunction {
private static EaseExponentialInOut INSTANCE;
private EaseExponentialInOut() {
}
public static EaseExponentialInOut getInstance() {
if (INSTANCE == null) {
INSTANCE = new EaseExponentialInOut();
}
return INSTANCE;
}
public float getPercentage(float pSecondsElapsed, float pDuration) {
float percentage = pSecondsElapsed / pDuration;
if (percentage < 0.5f) {
return EaseExponentialIn.getValue(2.0f * percentage) * 0.5f;
}
return (EaseExponentialOut.getValue((percentage * 2.0f) - 1.0f) * 0.5f) + 0.5f;
}
}
|
[
"[email protected]"
] | |
b7ae5bbd012f224993ea3ee5bb9617a1b56ded93
|
61ac4b4c207cb7e674fc5a8ac50e7a268f427a67
|
/src/main/java/net/licks92/EterniaCore/Plugin/PluginLogger.java
|
1d55afe370173ac12b553323ac8a08404dd081a8
|
[] |
no_license
|
axelpey/Eternia-Core
|
9aa3e47e564a89160c1b43eb0b13bf1092f20f31
|
bd193a8e11507a1df6a8ffe4ef1e814789e40a3a
|
refs/heads/master
| 2021-05-27T03:59:16.673604 | 2013-01-12T23:37:05 | 2013-01-12T23:37:05 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 937 |
java
|
package net.licks92.EterniaCore.Plugin;
import net.licks92.EterniaCore.EterniaLogger;
public class PluginLogger
{
private String prefix;
private EterniaLogger logger;
public PluginLogger(String pluginName)
{
prefix = "[" + pluginName + "]";
logger = new EterniaLogger();
}
public void debug(String msg)
{
logger.info(prefix + msg);
}
public void config(String msg)
{
logger.config(prefix + " " + msg);
}
public void fine(String msg)
{
logger.fine(prefix + " " + msg);
}
public void finer(String msg)
{
logger.finer(prefix + " " + msg);
}
public void finest(String msg)
{
logger.finest(prefix + " " + msg);
}
public void info(String msg)
{
logger.info(prefix + " " + msg);
}
public void severe(String msg)
{
logger.severe(prefix + " " + msg);
}
public void warning(String msg)
{
logger.warning(prefix + " " + msg);
}
}
|
[
"[email protected]"
] | |
a85159bb6276eca7d7155415bac8f8c9d6d59070
|
8a7aa2f2c17c197d564c5d9c6ea979ca620a20f4
|
/colsubsidio-cupo/src/main/java/com/aldeamo/docs/colsubsidio/cupo/conf/TransformerConfig.java
|
bb585e683326a2573a6d164fac9e9df2c72056dc
|
[] |
no_license
|
nagarciah/pocs
|
de91bb4cacaab945c11345e93cf8e97eec7b9482
|
fe0475c52caf65f110f94b3418b0624a66723121
|
refs/heads/master
| 2020-04-12T08:42:07.080716 | 2018-07-12T12:32:45 | 2018-07-12T12:32:45 | 39,162,466 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 276 |
java
|
package com.aldeamo.docs.colsubsidio.cupo.conf;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
@Configuration
@ImportResource("classpath:/transformer-beans.xml")
public class TransformerConfig {
}
|
[
"[email protected]"
] | |
8a25be226c0c98f18b24df7f549a26005cd4b5fd
|
744a2cdd9d4a782180af940a744af4c752bec043
|
/src/main/java/com/fake2edison/weibo4j/model/UserWapper.java
|
9ab2a6f81c72a18bf5eb662094bd69998c1b0a52
|
[] |
no_license
|
fake2edison/comfake2edisoneditor
|
64614898293d29294cfd7bd31fa2419851e44a6c
|
a5b6a110d676a13d9f80b58f44ddc496286221c5
|
refs/heads/master
| 2022-06-28T13:08:24.250067 | 2019-05-28T02:47:53 | 2019-05-28T02:47:53 | 186,224,678 | 0 | 0 | null | 2022-05-20T20:57:45 | 2019-05-12T07:26:26 |
Java
|
UTF-8
|
Java
| false | false | 2,101 |
java
|
/*
* UserObjectWapper.java created on 2010-7-28 上午08:48:35 by bwl (Liu Daoru)
*/
package com.fake2edison.weibo4j.model;
import java.io.Serializable;
import java.util.List;
/**
* 对User对象列表进行的包装，以支持cursor相关信息传递
* @author sinaWeibo
*/
public class UserWapper implements Serializable {
private static final long serialVersionUID = -3119107701303920284L;
/**
* 用户对象列表
*/
private List<User> users;
/**
* 向前翻页的cursor
*/
private long previousCursor;
/**
* 向后翻页的cursor
*/
private long nextCursor;
private long totalNumber;
private String hasvisible;
public UserWapper(List<User> users, long previousCursor, long nextCursor, long totalNumber,String hasvisible) {
this.users = users;
this.previousCursor = previousCursor;
this.nextCursor = nextCursor;
this.totalNumber=totalNumber;
this.hasvisible = hasvisible;
}
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
public long getPreviousCursor() {
return previousCursor;
}
public void setPreviousCursor(long previousCursor) {
this.previousCursor = previousCursor;
}
public long getNextCursor() {
return nextCursor;
}
public void setNextCursor(long nextCursor) {
this.nextCursor = nextCursor;
}
public long getTotalNumber() {
return totalNumber;
}
public void setTotalNumber(long totalNumber) {
this.totalNumber = totalNumber;
}
public String getHasvisible() {
return hasvisible;
}
public void setHasvisible(String hasvisible) {
this.hasvisible = hasvisible;
}
@Override
public String toString() {
String str="";
str += "UserWapper [users=[";
for(User u : users) {
str += u.toString() + " ";
}
str += "], ";
str += "previousCursor=" + previousCursor + ", ";
str += "nextCursor=" + nextCursor + ", ";
str += "totalNumber=" + totalNumber + ", ";
str += "hasvisible=" + hasvisible + "]";
return str;
}
}
|
[
"[email protected]"
] | |
0d575881f782e4b34032fce1e0413c4f97ad843f
|
511b11358b678d61f9ea03f1f47deae86f241383
|
/PS1/changhe3/Anagram.java
|
c447bc7c7ebe2711cc732ba8ad6a15a7bd7857b6
|
[] |
no_license
|
vasharm2/Homework
|
a9a04d36794400627a024882c41344d3771963a1
|
cb9ff936c4e7ab0d01c5b0d2045265afe5520118
|
refs/heads/master
| 2021-01-18T12:44:56.356044 | 2015-12-02T02:03:23 | 2015-12-02T02:03:23 | 43,036,226 | 0 | 0 | null | 2015-09-24T01:05:33 | 2015-09-24T01:05:30 | null |
UTF-8
|
Java
| false | false | 3,329 |
java
|
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Scanner;
/*
************************************************
____ ____ _ ___ __
/ ___/ ___| / |/ _ \ / /_
| | \___ \ | | (_) | '_ \
| |___ ___) | | |\__, | (_) |
\____|____/ |_| /_/ \___/
Problem set 1
Question 1
A common problem in computer science is finding patterns within data.
This problem will simulate that in a way that is easy to see what is happening.
A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward or forward.
Allowances may be made for adjustments to capital letters, punctuation, and word dividers.
an anagram is a word, phrase, or name formed by rearranging the letters of another.
Given a String S, determine if it is an anagram of a palindrome.
Return true if the String is an anagram of a palindrome, and false otherwise.
For example, the String “oatrtro” will return true (rotator), while the String “false” will return false.
PLEASE LOOK AT PS1.txt FOR MORE DETAILS!!!
************************************************
*/
public class Anagram {
public static boolean anagram(String input) {
char[] chars = input.toCharArray();
//Convert the input into the char array and sort it, so that the same characters will come together.
Arrays.sort(chars);
//Note that this is just an integer value wrapped as an int array. This is done because only through this way
//could the value be modified in a method, the code more organized.
int[] occurrenceOfOddChar = new int[]{0};
//This loop keeps track of the current character traversed throught, the numver of the current number,
// and number of characters that have an odd number of occurence. Return false if that number is greater
// than one.
char currentChar = chars[0];
int length = 0;
for (char c : chars) {
if (c == currentChar) {
length++;
} else {
checkLength(length, occurrenceOfOddChar);
if (occurrenceOfOddChar[0] > 1) return false;
currentChar = c;
length = 1;
}
}
//Call method checklength(int, int[]) again for the last few characters in the char array.
checkLength(length, occurrenceOfOddChar);
//Check if the last call of checklength(int, int[]) has incremented the occurrenceOfOddChar[0]
return occurrenceOfOddChar[0] < 2;
}
private static void checkLength(int length, int[] occurrenceOfOddChar) {
if (length % 2 == 1) {
occurrenceOfOddChar[0]++;
} else if (length < 1) {
throw new IllegalStateException();
}
}
public static void main(String[] args) {
File file = new File("Anagram.txt");
try {
Scanner scan = new Scanner(file);
int numberOfCases = scan.nextInt();
for (int i = 0; i < numberOfCases; i++) {
String input = scan.next();
System.out.println(anagram(input));
}
scan.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
|
[
"[email protected]"
] | |
f91c1661509028fd17f2de2dfd4f6241fb5bbcb7
|
5a73d52702f9525c4fc02dad0416ec9328ca9fde
|
/Android/Tasty/app/src/main/java/com/example/tasty/adapters/receita/ReceitaFavAdapter.java
|
b5fb4d49e817f7cfb35d592b4d983809ba72fa0a
|
[] |
no_license
|
piresflp/Tasty
|
01d315d0c4981df67d46e1e61d21f8606edacd26
|
0927cbb67bd372a50fde99b4ed673655fec587a4
|
refs/heads/main
| 2023-01-31T05:13:15.271185 | 2020-12-10T22:29:30 | 2020-12-10T22:29:30 | 315,624,916 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,003 |
java
|
package com.example.tasty.adapters.receita;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.example.tasty.R;
import com.example.tasty.retrofit.models.Receita;
import java.util.List;
public class ReceitaFavAdapter extends ArrayAdapter<Receita> {
Context context;
int layoutResourceId;
List<Receita> dados;
public ReceitaFavAdapter(@NonNull Context context, int resource, @NonNull List<Receita> dados) {
super(context, resource, dados);
//Informação global do ambiente. Define o resource usado
this.context = context;
//Id do layout que queremos usar de referência
this.layoutResourceId = resource;
//Lista de dados
this.dados = dados;
}
@NonNull
@Override
public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
View view = convertView;
//Verifica se existe alguma View pronta
if(view == null) {
/*
Setar o layout de produto
A classe LayoutInflater é usada para instaciar o conteudo do arquivo XML
nos objetos da View correspondente
Em outras palavras, ele pega um arquivo XML como entrada e cria os objetos View a partir dele
*/
LayoutInflater layoutinflater = LayoutInflater.from(context);
view = layoutinflater.inflate(layoutResourceId,parent,false);
}
TextView tvTitulo = (TextView) view.findViewById(R.id.tvFavNome);
TextView tvCategoria = (TextView) view.findViewById(R.id.tvFavCategoria);
Receita receita = dados.get(position);
tvTitulo.setText(receita.getTitulo());
tvCategoria.setText(receita.getCategoria().getNome());
return view;
}
}
|
[
"[email protected]"
] | |
0aa3cb0e920b1433b5911c35e8d07fd22f81dcab
|
0cf624a11577cf3a64663d2bc60453a3dd534676
|
/bjmashbing-sysio-master/src/main/java/com/teng/system/io/testreactor/MainThread.java
|
c13645a8060398aaaefc96c1a22424b601d72b73
|
[] |
no_license
|
longteng24/81plan-2021
|
9761a1acdbe2286510cea8860cc6b8cd1fb118c7
|
6e6efa5c2c557dfa4c131f67c91d062a79e3022f
|
refs/heads/main
| 2023-03-22T05:54:44.243665 | 2021-03-06T08:58:29 | 2021-03-06T08:58:29 | 329,466,788 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,124 |
java
|
package com.teng.system.io.testreactor;
/**
* @program: 81plan
* @description: 主程序
* @author: Mr.Teng
* @create: 2021-01-21 21:22
**/
public class MainThread {
public static void main(String[] args) {
//这里不做关于IO 和 业务的事情
//1.创建IO thread 一个或多个
SelectorThreadGroup boss = new SelectorThreadGroup(3); //boss线程组
SelectorThreadGroup worker = new SelectorThreadGroup(3); //worker线程组
//混杂模式，只有一个线程负责accept,每个都会被分配client,进行r/w
// SelectorThreadGroup stg = new SelectorThreadGroup(3);
//2.把监听9999 的server 注册到某一个selector 上
boss.setWorker(worker);
/**
* boss 里面选了一个线程注册 listen, 触发bind
* 从而这个选中的线程得持有 workerGroup 的引用
*
* 因为未来listen 一旦accept 得到client 后得去worker中 next出下一个线程分配
*/
boss.bind(9999);
boss.bind(8888);
boss.bind(7777);
boss.bind(6666);
}
}
|
[
"[email protected]"
] | |
49bc6b44ccf5555d7a1db1eb4f0e27c382d09421
|
7985a4b04ed48548371f9faa07d9bbe0c0f056c8
|
/src/org/traccar/protocol/HunterProProtocolDecoder.java
|
fc19257f63656b1853cf327d868e906b82b8678d
|
[
"Apache-2.0"
] |
permissive
|
enterstudio/traccar
|
5f393d9ab8991d275a0a1e1d69b4759a5a107832
|
886eb61ff0961d7e3be4e926d1510994b3df84e2
|
refs/heads/master
| 2023-04-30T04:49:46.776637 | 2017-02-21T10:46:36 | 2017-02-21T10:46:36 | 82,744,694 | 1 | 0 |
Apache-2.0
| 2023-09-02T13:38:03 | 2017-02-22T01:08:54 |
Java
|
UTF-8
|
Java
| false | false | 2,995 |
java
|
/*
* Copyright 2016 Anton Tananaev ([email protected])
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.traccar.protocol;
import org.jboss.netty.channel.Channel;
import org.traccar.BaseProtocolDecoder;
import org.traccar.DeviceSession;
import org.traccar.helper.DateBuilder;
import org.traccar.helper.Parser;
import org.traccar.helper.PatternBuilder;
import org.traccar.model.Position;
import java.net.SocketAddress;
import java.util.regex.Pattern;
public class HunterProProtocolDecoder extends BaseProtocolDecoder {
public HunterProProtocolDecoder(HunterProProtocol protocol) {
super(protocol);
}
private static final Pattern PATTERN = new PatternBuilder()
.number(">(d+)<") // identifier
.text("$GPRMC,")
.number("(dd)(dd)(dd).?d*,") // time
.expression("([AV]),") // validity
.number("(dd)(dd.d+),") // latitude
.expression("([NS]),")
.number("(ddd)(dd.d+),") // longitude
.expression("([EW]),")
.number("(d+.?d*)?,") // speed
.number("(d+.?d*)?,") // course
.number("(dd)(dd)(dd)") // date (ddmmyy)
.any()
.compile();
@Override
protected Object decode(
Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
Parser parser = new Parser(PATTERN, (String) msg);
if (!parser.matches()) {
return null;
}
Position position = new Position();
position.setProtocol(getProtocolName());
DeviceSession deviceSession = getDeviceSession(channel, remoteAddress, parser.next());
if (deviceSession == null) {
return null;
}
position.setDeviceId(deviceSession.getDeviceId());
DateBuilder dateBuilder = new DateBuilder();
dateBuilder.setTime(parser.nextInt(), parser.nextInt(), parser.nextInt());
position.setValid(parser.next().equals("A"));
position.setLatitude(parser.nextCoordinate());
position.setLongitude(parser.nextCoordinate());
position.setSpeed(parser.nextDouble());
position.setCourse(parser.nextDouble());
dateBuilder.setDateReverse(parser.nextInt(), parser.nextInt(), parser.nextInt());
position.setTime(dateBuilder.getDate());
return position;
}
}
|
[
"[email protected]"
] | |
9c61c08481fdcd7323433b80e309d1bad8ad36e0
|
0575519d38b04c3aaac0294e957e8bb709ba71f3
|
/BaseContructor/app/src/main/java/com/iblogstreet/basecontructor/activity/sendmessage/ContentActivity.java
|
32527dc12ec9315bcfdf93717e078bcae4029a08
|
[] |
no_license
|
sayhellotogithub/MyAndroid
|
36ff07a936bec245bc93f039e8c76e61a20200da
|
5767b3fbf9c848b06588f859d1d60f79c6f49619
|
refs/heads/master
| 2021-01-10T04:02:47.190375 | 2016-03-23T16:51:40 | 2016-03-23T16:51:40 | 54,399,699 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,688 |
java
|
package com.iblogstreet.basecontructor.activity.sendmessage;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;
import com.iblogstreet.basecontructor.R;
/**
* Created by Administrator on 2016/3/21.
*/
public class ContentActivity extends Activity implements AdapterView.OnItemClickListener {
private String[] objects;
ListView lv_send_message;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_sendmessage_list);
iniView();
iniValues();
iniListener();
}
private void iniView(){
lv_send_message=(ListView)findViewById(R.id.ll_send_message);
}
private void iniListener(){
lv_send_message.setOnItemClickListener(this);
}
private void iniValues(){
objects = new String[50];
for(int i=0;i<30;i++){
objects[i]="我是短信5550"+i;
}
lv_send_message.setAdapter(new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,objects));
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Log.d("ContentActivity",objects[position]);
Toast.makeText(this,objects[position],Toast.LENGTH_SHORT).show();
String data=objects[position];
Intent intent = new Intent();
intent.putExtra("sms",data);
setResult(RESULT_OK,intent);
finish();
}
}
|
[
"[email protected]"
] | |
14ba263e8c44f01399e340d13983c58f69132a21
|
71f2c8ed4ff86f129b93971e2f99d403926dd2bc
|
/qmui/src/main/java/com/qmuiteam/qmui/widget/section/QMUIStickySectionLayout.java
|
5825b8b2c7db1ad52b4cc4b519b2c86bad4e5622
|
[] |
no_license
|
xxxxxxxxxxj/BaseApplication
|
241ca7fe92eee6ca4be7ed415dc0164f6cb1193c
|
af395c16bd009f1d4169a7cbc5d2f5db64b52f3c
|
refs/heads/master
| 2020-08-09T16:16:11.498465 | 2019-12-13T09:19:27 | 2019-12-13T09:19:27 | 214,121,321 | 1 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 9,864 |
java
|
/*
* Tencent is pleased to support the open source community by making QMUI_Android available.
*
* Copyright (C) 2017-2018 THL A29 Limited, a Tencent company. All rights reserved.
*
* Licensed under the MIT License (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
*
* http://opensource.org/licenses/MIT
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.qmuiteam.qmui.widget.section;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.qmuiteam.qmui.layout.QMUIFrameLayout;
public class QMUIStickySectionLayout extends QMUIFrameLayout implements QMUIStickySectionAdapter.ViewCallback {
private RecyclerView mRecyclerView;
private QMUIFrameLayout mStickySectionWrapView;
private QMUIStickySectionItemDecoration mStickySectionItemDecoration;
private int mStickySectionViewHeight = -1;
/**
* if scrollToPosition happened before mStickySectionWrapView finished layout,
* the target item may be covered by mStickySectionWrapView, so we delay to
* execute the scroll action
*/
private Runnable mPendingScrollAction = null;
public QMUIStickySectionLayout(Context context) {
this(context, null);
}
public QMUIStickySectionLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public QMUIStickySectionLayout(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mStickySectionWrapView = new QMUIFrameLayout(context);
mRecyclerView = new RecyclerView(context);
addView(mRecyclerView, new LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
addView(mStickySectionWrapView, new LayoutParams
(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
mStickySectionWrapView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
mStickySectionViewHeight = bottom - top;
if (mStickySectionViewHeight > 0 && mPendingScrollAction != null) {
mPendingScrollAction.run();
mPendingScrollAction = null;
}
}
});
}
public void configStickySectionWrapView(StickySectionWrapViewConfig stickySectionWrapViewConfig) {
if (stickySectionWrapViewConfig != null) {
stickySectionWrapViewConfig.config(mStickySectionWrapView);
}
}
public QMUIFrameLayout getStickySectionWrapView() {
return mStickySectionWrapView;
}
public RecyclerView getRecyclerView() {
return mRecyclerView;
}
public @Nullable
View getStickySectionView() {
if (mStickySectionWrapView.getVisibility() != View.VISIBLE
|| mStickySectionWrapView.getChildCount() == 0) {
return null;
}
return mStickySectionWrapView.getChildAt(0);
}
/**
* proxy to {@link RecyclerView#setLayoutManager(RecyclerView.LayoutManager)}
*
* @param layoutManager LayoutManager to use
*/
public void setLayoutManager(@NonNull RecyclerView.LayoutManager layoutManager) {
mRecyclerView.setLayoutManager(layoutManager);
}
/**
* section header will be sticky when scrolling, see {@link #setAdapter(QMUIStickySectionAdapter, boolean)}
*
* @param adapter the adapter inherited from QMUIStickySectionAdapter
* @param <H> generic parameter of QMUIStickySectionAdapter, indicating the section header
* @param <T> generic parameter of QMUIStickySectionAdapter, indicating the section item
* @param <VH> generic parameter of QMUIStickySectionAdapter, indicating the view holder
*/
public <H extends QMUISection.Model<H>,
T extends QMUISection.Model<T>,
VH extends QMUIStickySectionAdapter.ViewHolder> void setAdapter(
QMUIStickySectionAdapter<H, T, VH> adapter) {
setAdapter(adapter, true);
}
/**
* set the adapter for recyclerView, the parameter sticky indicates whether
* the section header is sticky or not when scrolling.
*
* @param adapter the adapter inherited from QMUIStickySectionAdapter
* @param sticky if true, make the section header sticky when scrolling
* @param <H> generic parameter of QMUIStickySectionAdapter, indicating the section header
* @param <T> generic parameter of QMUIStickySectionAdapter, indicating the section item
* @param <VH> generic parameter of QMUIStickySectionAdapter, indicating the view holder
*/
public <H extends QMUISection.Model<H>,
T extends QMUISection.Model<T>,
VH extends QMUIStickySectionAdapter.ViewHolder> void setAdapter(
final QMUIStickySectionAdapter<H, T, VH> adapter, boolean sticky) {
if (sticky) {
QMUIStickySectionItemDecoration.Callback<VH> callback = new QMUIStickySectionItemDecoration.Callback<VH>() {
@Override
public int getRelativeStickyItemPosition(int pos) {
return adapter.getRelativeStickyPosition(pos);
}
@Override
public boolean isHeaderItem(int pos) {
return adapter.getItemViewType(pos) == QMUIStickySectionAdapter.ITEM_TYPE_SECTION_HEADER;
}
@Override
public VH createViewHolder(ViewGroup parent, int viewType) {
return adapter.createViewHolder(parent, viewType);
}
@Override
public void bindViewHolder(VH holder, int position) {
adapter.bindViewHolder(holder, position);
}
@Override
public int getItemViewType(int position) {
return adapter.getItemViewType(position);
}
@Override
public void registerAdapterDataObserver(RecyclerView.AdapterDataObserver observer) {
adapter.registerAdapterDataObserver(observer);
}
@Override
public void onHeaderVisibilityChanged(boolean visible) {
}
};
mStickySectionItemDecoration = new QMUIStickySectionItemDecoration<>(mStickySectionWrapView, callback);
mRecyclerView.addItemDecoration(mStickySectionItemDecoration);
}
adapter.setViewCallback(this);
mRecyclerView.setAdapter(adapter);
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (mStickySectionItemDecoration != null) {
mStickySectionWrapView.layout(mStickySectionWrapView.getLeft(),
mStickySectionItemDecoration.getTargetTop(),
mStickySectionWrapView.getRight(),
mStickySectionItemDecoration.getTargetTop() + mStickySectionWrapView.getHeight());
}
}
@Override
public void scrollToPosition(final int position, boolean isSectionHeader, final boolean scrollToTop) {
mPendingScrollAction = null;
RecyclerView.Adapter adapter = mRecyclerView.getAdapter();
if (adapter == null || position < 0 || position >= adapter.getItemCount()) {
return;
}
RecyclerView.LayoutManager layoutManager = mRecyclerView.getLayoutManager();
if (layoutManager instanceof LinearLayoutManager) {
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
int firstVPos = linearLayoutManager.findFirstCompletelyVisibleItemPosition();
int lastVPos = linearLayoutManager.findLastCompletelyVisibleItemPosition();
int offset = 0;
if (!isSectionHeader) {
if (mStickySectionViewHeight <= 0) {
// delay to re scroll
mPendingScrollAction = new Runnable() {
@Override
public void run() {
scrollToPosition(position, false, scrollToTop);
}
};
}
offset = mStickySectionWrapView.getHeight();
}
if (position < firstVPos + 1 /* increase one to avoid being covered */ || position > lastVPos || scrollToTop) {
linearLayoutManager.scrollToPositionWithOffset(position, offset);
}
} else {
mRecyclerView.scrollToPosition(position);
}
}
@Nullable
@Override
public RecyclerView.ViewHolder findViewHolderForAdapterPosition(int position) {
return mRecyclerView.findViewHolderForAdapterPosition(position);
}
@Override
public void requestChildFocus(View view) {
mRecyclerView.requestChildFocus(view, null);
}
public interface StickySectionWrapViewConfig {
void config(QMUIFrameLayout stickySectionWrapView);
}
}
|
[
"[email protected]"
] | |
fb43965eb0815f1dbb9c294065e8ed15fa74bfd9
|
fda9ce5162c8c926e19e009462de3a4c49e78599
|
/SpringInit/src/test/java/com/baiju/spring/init/SpringInit/SpringInitApplicationTests.java
|
81bc873147903576d9c3b12dcae9f74c6ea2fa92
|
[] |
no_license
|
baijuachari/SpringInitializr
|
477868ad35b393be5cf16a4c51dd7e2e3f03bdc1
|
b0ad4c56a460d0e023405312b942a4dd95f91f25
|
refs/heads/master
| 2021-05-07T22:44:59.030844 | 2017-10-26T09:37:30 | 2017-10-26T09:37:30 | 107,283,009 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 353 |
java
|
package com.baiju.spring.init.SpringInit;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringInitApplicationTests {
@Test
public void contextLoads() {
}
}
|
[
"[email protected]"
] | |
174fc4f6d8891cdf9357ce0c8b61e330b17178fe
|
532d5aaef9bb4fbebd14913e6ee0657db106f1bc
|
/SoftUniBlog/src/main/java/softuni/controller/HomeController.java
|
931347ec047060104afb39eac6ef5bab7f2d4e0e
|
[] |
no_license
|
thunderstorm773/SoftUniBlog
|
01b8795ba75ee9dba309cfd78d80f76b85d6db8c
|
130eed99bf527614725f553092cfb63d48701db9
|
refs/heads/master
| 2021-07-20T12:00:18.440606 | 2017-10-22T20:36:40 | 2017-10-22T20:36:40 | 107,900,404 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,839 |
java
|
package softuni.controller;
import mvcFramework.annotations.controller.Controller;
import mvcFramework.annotations.parameters.PathVariable;
import mvcFramework.annotations.request.GetMapping;
import mvcFramework.model.Model;
import softuni.models.viewModels.ShowArticle;
import softuni.models.viewModels.ShowCategory;
import softuni.services.api.ArticleService;
import softuni.services.api.CategoryService;
import softuni.staticData.Constants;
import javax.ejb.Stateless;
import javax.inject.Inject;
import java.util.List;
@Stateless
@Controller
public class HomeController {
private CategoryService categoryService;
@Inject
public HomeController(CategoryService categoryService) {
this.categoryService = categoryService;
}
@GetMapping("/")
public String home() {
return "redirect:/index";
}
@GetMapping("/index")
public String index(Model model) {
List<ShowCategory> categories = this.categoryService.findAll();
model.addAttribute(Constants.CATEGORIES_KEY, categories);
model.addAttribute(Constants.TITLE_KEY, Constants.INDEX_TITLE_VALUE);
model.addAttribute(Constants.VIEW_KEY, Constants.INDEX_VIEW_VALUE);
return "base-layout";
}
@GetMapping("/category/{id}/articles")
public String getAllArticlesForCategory(@PathVariable("id") Long id,
Model model) {
ShowCategory category = this.categoryService.findById(id);
if (category == null) {
return "redirect:/index";
}
model.addAttribute(Constants.CATEGORY_KEY, category);
model.addAttribute(Constants.TITLE_KEY, Constants.SEARCH_BY_CATEGORY_TITLE_VALUE);
model.addAttribute(Constants.VIEW_KEY, Constants.SEARCH_BY_CATEGORY_VIEW_VALUE);
return "base-layout";
}
}
|
[
"[email protected]"
] | |
f5080ec5acecc17499970dc38d744cdcf9cb3d40
|
3c3abf29eac695dd6d10647a8cd9f42e692d2b6b
|
/module_2/OpTap/src/model/Car.java
|
f875e7c66c48a05fdb4edb6f70e081a0400f789c
|
[] |
no_license
|
phuongthao101/C0221G1DaoNgocPhuongThao
|
81777a445874f8dc1f4da008fca764b1d7e7deba
|
5cac525bbe1c980c551ef9977228043fc7dbd929
|
refs/heads/master
| 2023-06-23T02:27:20.531284 | 2021-07-22T01:12:24 | 2021-07-22T01:12:24 | 342,120,480 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,079 |
java
|
package model;
public class Car extends Vehicle{
//+ Ôtô có thêm các thuộc tính : Số chỗ ngồi, kiểu xe (du lịch, xe khách).
private String seat;
private String type;
// public Car(String palate, String nameProduction, int yearProduct, String owner, String seat) {
// super(palate, nameProduction, yearProduct, owner);
// this.seat = seat;
// }
public Car(String palate, String nameProduction, int yearProduct, String owner, String seat, String type) {
super(palate, nameProduction, yearProduct, owner);
this.seat = seat;
this.type = type;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
// @Override
// public String toString() {
// return String.format("%s,3,%s,%s",super.toString(),type,seat);
//
// }
@Override
public void showInfo() {
}
}
|
[
"[email protected]"
] | |
88e91ea8cd58cadfac7beed7293d097464d6c999
|
5dd80bb1ab0e1b5fbadea690cccf620ef039202b
|
/kodila-testing/src/main/java/com/kodilla/testing/forum/ForumComment.java
|
aad96409acf04e7caffebd8dd4c2f7ac863a7c3a
|
[] |
no_license
|
MateuszSzCz-1/Mateusz-Szczerba-kodilla-java
|
df7a235cdb9b3b2498cb2cf54602616b95035caa
|
738547bf45b113f20924853a752804db1c434e30
|
refs/heads/master
| 2023-08-21T07:51:55.124130 | 2021-10-31T11:38:14 | 2021-10-31T11:38:14 | 353,497,371 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,146 |
java
|
package com.kodilla.testing.forum;
public class ForumComment {
private ForumPost forumPost;
private String commentBody;
private String author;
public ForumComment(ForumPost forumPost, String commentBody, String author) {
this.forumPost = forumPost;
this.commentBody = commentBody;
this.author = author;
}
public ForumPost getForumPost() {
return forumPost;
}
public String getCommentBody() {
return commentBody;
}
public String getAuthor() {
return author;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ForumComment)) return false;
ForumComment that = (ForumComment) o;
if (!forumPost.equals(that.forumPost)) return false;
if (!commentBody.equals(that.commentBody)) return false;
return author.equals(that.author);
}
@Override
public int hashCode() {
int result = forumPost.hashCode();
result = 31 * result + commentBody.hashCode();
result = 31 * result + author.hashCode();
return result;
}
}
|
[
"[email protected]"
] | |
3c0692535c21efdb93b719dbb697fdd4aa8eaba2
|
e95463689b7659af8d16fa774e52da249a9c28c8
|
/src/main/java/main/ValidadorDeContrasenia.java
|
a182044ee43b9bfa9b5bf409293f08f3b40ae5d6
|
[] |
no_license
|
FrancoCingolani/TPdds2020_Grupo8
|
9f345a82a1d67e487c34344f32f1075aaecad692
|
da0c62c9907da9c65e574c697a993052c42d3b52
|
refs/heads/master
| 2023-02-01T15:41:49.070679 | 2020-12-16T13:44:15 | 2020-12-16T13:44:15 | 251,153,129 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,839 |
java
|
package main;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.*;
import exceptions.ContraseniaCaracteresRepetidosException;
import exceptions.ContraseniaCortaException;
import exceptions.ContraseniaInseguraException;
import exceptions.ContraseniaUnicodeException;
import java.nio.charset.Charset;
public class ValidadorDeContrasenia {
private static ValidadorDeContrasenia instance;
private ValidadorDeContrasenia() {
}
public static ValidadorDeContrasenia getInstance() {
if(instance == null) {
instance = new ValidadorDeContrasenia();
}
return instance;
}
public static boolean isPureAscii(String v) {
return Charset.forName("US-ASCII").newEncoder().canEncode(v);
// or "ISO-8859-1" for ISO Latin 1
// or StandardCharsets.US_ASCII with JDK1.7+
}
public void validar(String contrasenia) throws FileNotFoundException, IOException {
if((contrasenia.length()<= 8) && (contrasenia.length()<= 64)) {
throw new ContraseniaCortaException();
}
if(ValidadorDeContrasenia.isPureAscii(contrasenia) == false) {
throw new ContraseniaUnicodeException();
}
Pattern pattern = Pattern.compile("(.)\\1\\1", Pattern.CASE_INSENSITIVE);
Matcher m = pattern.matcher(contrasenia);
if (m.find()) {
throw new ContraseniaCaracteresRepetidosException();
}
File file = new File("./files/topContraseniasInseguras.txt");
String cadena;
FileReader f = new FileReader(file);
BufferedReader b = new BufferedReader(f);
while((cadena = b.readLine())!=null) {
if(cadena.equals(contrasenia)) {
throw new ContraseniaInseguraException();
}
}
b.close();
System.out.println("Contraseña segura");
}
}
|
[
"[email protected]"
] | |
c9bf92fa6977b6da905094a410c681b4dbe1fc86
|
3ce85d26d4df20d439d90023550262ebf012af9b
|
/android/src/main/java/com/hoxfon/react/RNTwilioVoice/ProximityManager.java
|
69575f1ebbda00cf68b97e950e582d73ab506551
|
[
"MIT"
] |
permissive
|
gitstud/react-native-twilio-programmable-voice
|
5480c7fe7fa0ad6aaaa2f802395de00f893640c1
|
e86dd26ab0d89039d0c5d83b3599ac96de82c97d
|
refs/heads/master
| 2020-08-01T14:11:19.889895 | 2019-09-26T06:49:24 | 2019-09-26T06:49:24 | 211,018,686 | 2 | 0 |
MIT
| 2019-09-26T06:42:38 | 2019-09-26T06:42:37 | null |
UTF-8
|
Java
| false | false | 6,478 |
java
|
package com.hoxfon.react.RNTwilioVoice;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.Log;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.WritableMap;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import static com.hoxfon.react.RNTwilioVoice.EventManager.EVENT_PROXIMITY;
import static com.hoxfon.react.RNTwilioVoice.TwilioVoiceModule.TAG;
public class ProximityManager {
private static final String ERROR_PROXIMITY_SENSOR_NOT_SUPPORTED = "Proximity sensor is not supported.";
private static final String ERROR_PROXIMITY_LOCK_NOT_SUPPORTED = "Proximity lock is not supported.";
private SensorManager sensorManager;
private Sensor proximitySensor;
private SensorEventListener proximityListener;
private WakeLock proximityWakeLock = null;
private PowerManager powerManager;
private EventManager eventManager;
public ProximityManager(ReactApplicationContext context, EventManager em) {
eventManager = em;
powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
initProximityWakeLock();
}
private void initProximityWakeLock() {
// Check if PROXIMITY_SCREEN_OFF_WAKE_LOCK is implemented, not part of public api.
// PROXIMITY_SCREEN_OFF_WAKE_LOCK and isWakeLockLevelSupported are available from api 21
try {
boolean isSupported;
int proximityScreenOffWakeLock;
if (android.os.Build.VERSION.SDK_INT < 21) {
Field field = PowerManager.class.getDeclaredField("PROXIMITY_SCREEN_OFF_WAKE_LOCK");
proximityScreenOffWakeLock = (Integer) field.get(null);
Method method = powerManager.getClass().getDeclaredMethod("getSupportedWakeLockFlags");
int powerManagerSupportedFlags = (Integer) method.invoke(powerManager);
isSupported = ((powerManagerSupportedFlags & proximityScreenOffWakeLock) != 0x0);
} else {
proximityScreenOffWakeLock = powerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK;
isSupported = powerManager.isWakeLockLevelSupported(proximityScreenOffWakeLock);
}
if (isSupported) {
proximityWakeLock = powerManager.newWakeLock(proximityScreenOffWakeLock, TAG);
proximityWakeLock.setReferenceCounted(false);
}
} catch (Exception e) {
Log.e(TAG, "Failed to get proximity screen locker.");
}
}
private void turnScreenOn() {
if (proximityWakeLock == null) {
if (BuildConfig.DEBUG) {
Log.d(TAG, ERROR_PROXIMITY_LOCK_NOT_SUPPORTED);
}
return;
}
synchronized (proximityWakeLock) {
if (proximityWakeLock.isHeld()) {
if (BuildConfig.DEBUG) {
Log.d(TAG, "turnScreenOn()");
}
if (android.os.Build.VERSION.SDK_INT >= 21) {
proximityWakeLock.release(PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY);
}
}
}
}
private void turnScreenOff() {
if (proximityWakeLock == null) {
if (BuildConfig.DEBUG) {
Log.d(TAG, ERROR_PROXIMITY_LOCK_NOT_SUPPORTED);
}
return;
}
synchronized (proximityWakeLock) {
if (!proximityWakeLock.isHeld()) {
if (BuildConfig.DEBUG) {
Log.d(TAG, "turnScreenOff()");
}
proximityWakeLock.acquire();
}
}
}
private void initProximitySensorEventListener() {
if (proximityListener != null) {
return;
}
if (BuildConfig.DEBUG) {
Log.d(TAG, "initProximitySensorEventListener()");
}
proximityListener = new SensorEventListener() {
@Override
public void onSensorChanged(SensorEvent sensorEvent) {
if (sensorEvent.sensor.getType() == Sensor.TYPE_PROXIMITY) {
boolean isNear = false;
if (sensorEvent.values[0] < proximitySensor.getMaximumRange()) {
isNear = true;
}
if (isNear) {
turnScreenOff();
} else {
turnScreenOn();
}
WritableMap data = Arguments.createMap();
data.putBoolean("isNear", isNear);
eventManager.sendEvent(EVENT_PROXIMITY, data);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
};
}
public void startProximitySensor() {
if (proximitySensor == null) {
Log.e(TAG, ERROR_PROXIMITY_SENSOR_NOT_SUPPORTED);
return;
}
initProximitySensorEventListener();
if (proximityListener != null) {
if (BuildConfig.DEBUG) {
Log.d(TAG, "register proximity listener");
}
// SensorManager.SENSOR_DELAY_FASTEST(0 ms),
// SensorManager.SENSOR_DELAY_GAME(20 ms),
// SensorManager.SENSOR_DELAY_UI(60 ms),
// SensorManager.SENSOR_DELAY_NORMAL(200 ms)
sensorManager.registerListener(
proximityListener,
proximitySensor,
SensorManager.SENSOR_DELAY_NORMAL
);
}
}
public void stopProximitySensor() {
if (proximitySensor == null) {
Log.e(TAG, ERROR_PROXIMITY_SENSOR_NOT_SUPPORTED);
return;
}
if (proximityListener != null) {
if (BuildConfig.DEBUG) {
Log.d(TAG, "unregister proximity listener");
}
sensorManager.unregisterListener(proximityListener);
proximityListener = null;
}
}
}
|
[
"[email protected]"
] | |
27e070bcb31fb0c2e2ae746866ce7ec748ae167a
|
52c36ce3a9d25073bdbe002757f08a267abb91c6
|
/src/main/java/com/alipay/api/response/KoubeiCateringKdsInfoQueryResponse.java
|
6445af81b55f2e5deda029dac6f5a03a27c0acda
|
[
"Apache-2.0"
] |
permissive
|
itc7/alipay-sdk-java-all
|
d2f2f2403f3c9c7122baa9e438ebd2932935afec
|
c220e02cbcdda5180b76d9da129147e5b38dcf17
|
refs/heads/master
| 2022-08-28T08:03:08.497774 | 2020-05-27T10:16:10 | 2020-05-27T10:16:10 | 267,271,062 | 0 | 0 |
Apache-2.0
| 2020-05-27T09:02:04 | 2020-05-27T09:02:04 | null |
UTF-8
|
Java
| false | false | 906 |
java
|
package com.alipay.api.response;
import java.util.List;
import com.alipay.api.internal.mapping.ApiField;
import com.alipay.api.internal.mapping.ApiListField;
import com.alipay.api.domain.KdsInfoModel;
import com.alipay.api.AlipayResponse;
/**
* ALIPAY API: koubei.catering.kds.info.query response.
*
* @author auto create
* @since 1.0, 2019-03-05 15:48:56
*/
public class KoubeiCateringKdsInfoQueryResponse extends AlipayResponse {
private static final long serialVersionUID = 4673672456279461752L;
/**
* kds 配置信息列表
*/
@ApiListField("kds_info_model_list")
@ApiField("kds_info_model")
private List<KdsInfoModel> kdsInfoModelList;
public void setKdsInfoModelList(List<KdsInfoModel> kdsInfoModelList) {
this.kdsInfoModelList = kdsInfoModelList;
}
public List<KdsInfoModel> getKdsInfoModelList( ) {
return this.kdsInfoModelList;
}
}
|
[
"[email protected]"
] | |
06166f6ebb966153c5a7ced85d2a9cb78291501e
|
bd7d0dafcdb59d202dcaf1552558997d6fce0dce
|
/blog_utils/src/main/java/com/xzh/blog/utils/plugins/rename/RenameJavaMapperPlugin.java
|
fa497b829b443387e4574241e8838103a2e81890
|
[] |
no_license
|
Molzx/myblog
|
ab45186b26a38f9ea8db0fa8f9e0f50be14cd9a9
|
29faf74afe82082089396223bf3a5c0004796d49
|
refs/heads/master
| 2022-06-22T21:06:09.376364 | 2019-11-25T12:54:42 | 2019-11-25T12:54:42 | 223,946,383 | 0 | 0 | null | 2022-06-21T02:18:54 | 2019-11-25T12:43:31 |
Java
|
UTF-8
|
Java
| false | false | 2,078 |
java
|
/**
* FileName: RenameJavaMapperPlugin
* Author: xuzhenghao
* Date: 2019/11/24 17:08
* Description: Mapper.java改为Dao.java
*/
package com.xzh.blog.utils.plugins.rename;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.PluginAdapter;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
import static org.mybatis.generator.internal.util.messages.Messages.getString;
/**
* 〈Mapper.java改为Dao.java〉
*/
public class RenameJavaMapperPlugin extends PluginAdapter {
private String searchString;
private String replaceString;
private Pattern pattern;
public RenameJavaMapperPlugin() {
}
public boolean validate(List<String> warnings) {
searchString = properties.getProperty("searchString"); //$NON-NLS-1$
replaceString = properties.getProperty("replaceString"); //$NON-NLS-1$
boolean valid = stringHasValue(searchString)
&& stringHasValue(replaceString);
if (valid) {
pattern = Pattern.compile(searchString);
} else {
if (!stringHasValue(searchString)) {
warnings.add(getString("ValidationError.18", //$NON-NLS-1$
"RenameExampleClassPlugin", //$NON-NLS-1$
"searchString")); //$NON-NLS-1$
}
if (!stringHasValue(replaceString)) {
warnings.add(getString("ValidationError.18", //$NON-NLS-1$
"RenameExampleClassPlugin", //$NON-NLS-1$
"replaceString")); //$NON-NLS-1$
}
}
return valid;
}
@Override
public void initialized(IntrospectedTable introspectedTable) {
String oldType = introspectedTable.getMyBatis3JavaMapperType();
Matcher matcher = pattern.matcher(oldType);
oldType = matcher.replaceAll(replaceString);
introspectedTable.setMyBatis3JavaMapperType(oldType);
}
}
|
[
"[email protected]"
] | |
81d0601645c12c11b613668acc439f45863e68a6
|
567caa81bd0b1d9d9b0d34a924d147b7b60a66e0
|
/spring-boot-samples/spring-boot-sample-web-secure-custom/src/test/java/sample/web/secure/custom/SampleWebSecureCustomApplicationTests.java
|
b7347dd8c4b207b0a9dd0515a7485ffd7ff56415
|
[
"Noweb",
"Apache-2.0"
] |
permissive
|
MrSorrow/spring-boot
|
fb06c692f35dfb88ee6a8f3fa540e0ebef21de8f
|
ceed0e80af969c778b5c25c64e5124105988aab9
|
refs/heads/master
| 2023-01-10T07:09:07.443658 | 2019-10-14T07:39:17 | 2019-10-14T07:39:17 | 182,507,696 | 1 | 0 |
Apache-2.0
| 2022-12-27T14:44:13 | 2019-04-21T08:16:26 |
Java
|
UTF-8
|
Java
| false | false | 4,308 |
java
|
/*
* Copyright 2012-2017 the original author or authors.
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package sample.web.secure.custom;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Basic integration tests for demo application.
*
* @author Dave Syer
*/
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class SampleWebSecureCustomApplicationTests {
@Autowired
private TestRestTemplate restTemplate;
@LocalServerPort
private int port;
@Test
public void testHome() {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.TEXT_HTML));
ResponseEntity<String> entity = this.restTemplate.exchange("/", HttpMethod.GET,
new HttpEntity<Void>(headers), String.class);
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.FOUND);
assertThat(entity.getHeaders().getLocation().toString())
.endsWith(this.port + "/login");
}
@Test
public void testLoginPage() {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.TEXT_HTML));
ResponseEntity<String> entity = this.restTemplate.exchange("/login",
HttpMethod.GET, new HttpEntity<Void>(headers), String.class);
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(entity.getBody()).contains("_csrf");
}
@Test
public void testLogin() {
HttpHeaders headers = getHeaders();
headers.setAccept(Arrays.asList(MediaType.TEXT_HTML));
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
MultiValueMap<String, String> form = new LinkedMultiValueMap<>();
form.set("username", "user");
form.set("password", "password");
ResponseEntity<String> entity = this.restTemplate.exchange("/login",
HttpMethod.POST, new HttpEntity<>(form, headers), String.class);
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.FOUND);
assertThat(entity.getHeaders().getLocation().toString())
.endsWith(this.port + "/");
assertThat(entity.getHeaders().get("Set-Cookie")).isNotNull();
}
private HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
ResponseEntity<String> page = this.restTemplate.getForEntity("/login",
String.class);
assertThat(page.getStatusCode()).isEqualTo(HttpStatus.OK);
String cookie = page.getHeaders().getFirst("Set-Cookie");
headers.set("Cookie", cookie);
Pattern pattern = Pattern.compile("(?s).*name=\"_csrf\".*?value=\"([^\"]+).*");
Matcher matcher = pattern.matcher(page.getBody());
assertThat(matcher.matches()).as(page.getBody()).isTrue();
headers.set("X-CSRF-TOKEN", matcher.group(1));
return headers;
}
@Test
public void testCss() {
ResponseEntity<String> entity = this.restTemplate
.getForEntity("/css/bootstrap.min.css", String.class);
assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(entity.getBody()).contains("body");
}
}
|
[
"[email protected]"
] | |
0e03ddd017b0af3fcb11c8d6edbdd30d69298faa
|
d4a2caf1a3c4010c12289181087df11d7e8d7c70
|
/src/com/iup/tp/twitup/datamodel/IDatabase.java
|
2357b51d6c4da25ef9f38d38874c53748c57c7e0
|
[] |
no_license
|
Sanctuspetrus/TwitupProjet
|
107342c1f8192f06bcdcbc519d0be44781b61c5d
|
d8a20122251d01f392200f2b35df61bae2aa2b99
|
refs/heads/master
| 2021-01-20T10:30:40.708883 | 2017-02-27T16:19:26 | 2017-02-27T16:19:26 | 80,806,544 | 0 | 0 | null | null | null | null |
ISO-8859-1
|
Java
| false | false | 2,747 |
java
|
package com.iup.tp.twitup.datamodel;
import java.util.Set;
/**
* Interface de la base de données de l'application.
*
* @author S.Lucas
*/
public interface IDatabase {
/**
* Ajoute un observateur sur les modifications de la base de données.
*
* @param observer
*/
void addObserver(IDatabaseObserver observer);
/**
* Supprime un observateur sur les modifications de la base de données.
*
* @param observer
*/
void deleteObserver(IDatabaseObserver observer);
/**
* Retourne la liste des utilisateurs
*/
Set<User> getUsers();
/**
* Retourne la liste des twits
*/
Set<Twit> getTwits();
/**
* Ajoute un twit à la base de données.
*
* @param twitToAdd
*/
void addTwit(Twit twitToAdd);
/**
* Supprime un twit de la base de données.
*
* @param twitToRemove
*/
void removeTwit(Twit twitToRemove);
/**
* Modification d'un twit de la base de données. <br/>
* <i>Normalement peu probable qu'un twit soit modifié...</i>
*
* @param twitToModify
*/
void modifiyTwit(Twit twitToModify);
/**
* Ajoute un utilisateur à la base de données.
*
* @param userToAdd
*/
void addUser(User userToAdd);
/**
* Supprime un utilisateur de la base de données.
*
* @param userToRemove
*/
void removeUser(User userToRemove);
/**
* Modification d'un utilisateur de la base de données.
*
* @param userToModify
*/
void modifiyUser(User userToModify);
/**
* Supprime l'intégralité des twits enregistrés.
*/
void clearTwits();
/**
* Supprime l'intégralité des utilisateurs enregistrés.
*/
void clearUsers();
/**
* Supprime l'intégralité des données.
*/
void clear();
/**
* Retourne tous les Twits présents en base ayant le tag donné
*
* @param tag
* , tag à rechercher.
*/
Set<Twit> getTwitsWithTag(String tag);
/**
* Retourne tous les Twits présents en base ayant le tag utilisateur donné
*
* @param userTag
* , tag utilisateur à rechercher.
*/
Set<Twit> getTwitsWithUserTag(String userTag);
/**
* Retourne tous les Twits d'un utilisateur.
*
* @param user
* , utilisateur dont les twits sont à rechercher.
*/
Set<Twit> getUserTwits(User user);
/**
* Retourne tous les utilisateurs suivant l'utilisateur donnée
*
* @param user
* , utilisateur dont les followers sont à rechercher.
*/
Set<User> getFollowers(User user);
/**
* Retourne le nombre de followers pour l'utilisateur donné.
*
* @param user
* , utilisateur dont le nombre de followers est à rechercher.
*/
int getFollowersCount(User user);
/**
* Retourne l'utilisateur inconnu du système.
*/
public User getUnknowUser();
}
|
[
"[email protected]"
] | |
b9e7c967014505adc3b9ac5ba85aa95f8b5ba9a7
|
5455505da953e3078ed13eff45a4731ab1ea21cd
|
/sources/com/jelsat/fragments/CalendarDatesCostUpdateFragment$1.java
|
0fced96eff830162abc1b77d00b58e54d626bde8
|
[] |
no_license
|
pavankvch/Jel
|
b673523dc7a1b33655d36d1cb62b7b8f31881397
|
f35cf5ea71288e588cc642fc691a78c4dcd1c250
|
refs/heads/master
| 2020-04-29T10:37:00.566486 | 2019-03-17T07:34:39 | 2019-03-17T07:34:39 | 176,067,567 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,490 |
java
|
package com.jelsat.fragments;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import com.data.payments.HostProperty;
import com.jelsat.R;
class CalendarDatesCostUpdateFragment$1 implements OnItemSelectedListener {
final /* synthetic */ CalendarDatesCostUpdateFragment this$0;
public void onNothingSelected(AdapterView<?> adapterView) {
}
CalendarDatesCostUpdateFragment$1(CalendarDatesCostUpdateFragment calendarDatesCostUpdateFragment) {
this.this$0 = calendarDatesCostUpdateFragment;
}
public void onItemSelected(AdapterView<?> adapterView, View view, int i, long j) {
this.this$0.norecordsTv.setVisibility(0);
this.this$0.daysLayout.setVisibility(8);
this.this$0.calendarPickerView.setVisibility(8);
this.this$0.dateRangeIv.setVisibility(8);
if (this.this$0.spinner_nav.getSelectedItem().toString().trim().equals(this.this$0.getString(R.string.calender_cost_select_property)) != null) {
CalendarDatesCostUpdateFragment.access$002(this.this$0, 0);
this.this$0.showToast(this.this$0.getString(R.string.calender_cost_please_select_prop));
return;
}
CalendarDatesCostUpdateFragment.access$002(this.this$0, Integer.parseInt(((HostProperty) adapterView.getItemAtPosition(i)).getPropertyId()));
this.this$0.loadCalender(CalendarDatesCostUpdateFragment.access$000(this.this$0));
}
}
|
[
"[email protected]"
] | |
88c8cf1cf2285e88350fb1dd7838de1d9bf52900
|
4fb2167912a5092a69d358b21994eb4d2d843e12
|
/src/main/java/org/pho/splitter/core/splits/primitives/package-info.java
|
18593040116b51c44e885d371f8cd0458d6ad1e4
|
[] |
no_license
|
ortolanph/stringsplitter
|
a91a8cc31d10f6c4dec278d0d1fccff26fba2b0a
|
81de3a7161975083eb1725cf7094cb9b71a1af2f
|
refs/heads/master
| 2020-03-25T22:05:23.254156 | 2020-01-03T16:10:50 | 2020-01-03T16:10:50 | 144,205,278 | 1 | 1 | null | 2020-01-03T00:23:33 | 2018-08-09T21:27:26 |
Java
|
UTF-8
|
Java
| false | false | 1,186 |
java
|
/**
* With this API is possible to convert a String split into a wrapper of a primitive data type. The following table lists all the wrappers and splitters.
* <br><br>
* <table>
* <caption>Wrapper splitters</caption>
* <tr>
* <td><strong>Wrapper</strong></td>
* <td><strong>Splitter</strong></td>
* </tr>
* <tr>
* <td><code>Byte</code></td>
* <td>ByteSplit</td>
* </tr>
* <tr>
* <td><code>Character</code></td>
* <td>CharacterSplit</td>
* </tr>
* <tr>
* <td><code>Short</code></td>
* <td>ShortSplit</td>
* </tr>
* <tr>
* <td><code>Integer</code></td>
* <td>IntegerSplit</td>
* </tr>
* <tr>
* <td><code>Long</code></td>
* <td>LongSplit</td>
* </tr>
* <tr>
* <td><code>Float</code></td>
* <td>FloatSplit</td>
* </tr>
* <tr>
* <td><code>Double</code></td>
* <td>FloatSplit</td>
* </tr>
* <tr>
* <td><code>Boolean</code></td>
* <td>BooleanSplit</td>
* </tr>
* </table>
* <br>
*/
package org.pho.splitter.core.splits.primitives;
|
[
"[email protected]"
] | |
d5f9aa43fffaaaca75bf9aaa658018cde3635413
|
0474ea2fff83e97eaeec4feea3b9ae83b833a991
|
/app/src/main/java/com/caesar/checkdemo/SingleSelectionActivity.java
|
432c6e401e7a37c158162d673bd08da300d25546
|
[] |
no_license
|
noahPassword/AndroidFunctionDemo
|
e863949733cb17ff134744ef67b4804f5d379a0c
|
491de9cc287be4ed7bf631bd4fce96d4bbdf4634
|
refs/heads/master
| 2021-06-12T23:35:16.997973 | 2017-03-21T07:28:03 | 2017-03-21T07:28:03 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,974 |
java
|
package com.caesar.checkdemo;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.TextView;
import com.caesar.checkdemo.adapter.SingleSelectAdapter;
import com.caesar.checkdemo.ui.DividerGridItemDecoration;
/**
* 单选列表
* Created by caesar on 2016/9/29.
* 修订历史:
*/
public class SingleSelectionActivity extends AppCompatActivity {
private RecyclerView mRecyclerView;
private TextView mTextView2;
private SingleSelectAdapter mAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.single_activity);
initView();
initData();
}
/** 初始化布局*/
private void initView() {
mTextView2 = (TextView) findViewById(R.id.tv2);
mRecyclerView = (RecyclerView) findViewById(R.id.rv);
mTextView2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mTextView2.setText("选中了"+SingleSelectAdapter.selectPosition);
}
});
}
/** 初始化数据 */
private void initData() {
//列表
//mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
mRecyclerView.setLayoutManager(new GridLayoutManager(this,3));
//适配器
mAdapter = new SingleSelectAdapter(SingleSelectionActivity.this);
mAdapter.setOnItemClickLitener(new SingleSelectAdapter.OnItemClickListener() {
@Override
public void onItemClick(View view, int position) {
SingleSelectAdapter.selectPosition = position;
}
});
mRecyclerView.setAdapter(mAdapter);
mRecyclerView.addItemDecoration(new DividerGridItemDecoration(this));
}
}
|
[
"[email protected]"
] | |
dd7c450a11191bd28a7724a979b4e6231aa922f7
|
759347a5b75f088e1ba04571782e6a5d3ca69825
|
/traditional_mutants/boolean_elementwise_not_equal(int,int)/LOI_346/MethodCollection2.java
|
5a0c699af9b5467a5fa99f3704f71cdf59946cb4
|
[] |
no_license
|
ps073006/testJavaMR
|
218248584c64d1c239a5c428571b4cff44143484
|
3c6d9c5188c3ce4cefe0b3be5a4685503bb00f1b
|
refs/heads/master
| 2021-01-10T04:37:47.334249 | 2016-02-02T02:22:28 | 2016-02-02T02:22:28 | 50,891,432 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 11,824 |
java
|
// This is a mutant program.
// Author : ysma
package Test;
public class MethodCollection2
{
public static int add_values( int[] a )
{
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
}
return sum;
}
public static double add_two_array_values( int[] a, int i, int j )
{
if (i < 0 || i >= a.length || j < 0 || j >= a.length) {
return -100000;
} else {
return a[i] + a[j] / 2.0;
}
}
public static int[] bubble( int[] a )
{
int i;
int j;
int t;
for (i = a.length - 2; i >= 0; i--) {
for (j = 0; j <= i; j++) {
if (a[j] > a[j + 1]) {
t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
return a;
}
public static int[] shell_sort( int[] a )
{
int j;
int i;
int k;
int m;
int mid;
for (m = a.length / 2; m > 0; m /= 2) {
for (j = m; j < a.length; j++) {
for (i = j - m; i >= 0; i -= m) {
if (a[i + m] >= a[i]) {
break;
} else {
mid = a[i];
a[i] = a[i + m];
a[i + m] = mid;
}
}
}
}
return a;
}
public static int sequential_search( int[] a, int key )
{
int i;
for (i = 0; i < a.length; i++) {
if (a[i] == key) {
return i;
}
}
return -1;
}
public static int[] selection_sort( int[] list )
{
int i;
int j;
int min;
for (i = 0; i < list.length - 1; i++) {
min = i;
for (j = i + 1; j < list.length; j++) {
if (list[j] < list[min]) {
min = j;
}
}
int tmp = list[i];
list[i] = list[min];
list[min] = tmp;
}
return list;
}
public static int add_values_in_two_arrays( int[] a, int[] b, int i )
{
if (i < 0 || i >= a.length || i >= b.length) {
return -100000;
} else {
return a[i] + b[i];
}
}
public static int dot_product( int[] a, int[] b )
{
int sum = 0;
int i;
for (i = 0; i < a.length; i++) {
sum += a[i] * b[i];
}
return sum;
}
public static int[] array_calc1( int[] a, int k )
{
int i;
int[] b = new int[a.length];
for (i = 0; i < a.length; i++) {
b[i] = a[i] / k;
}
return b;
}
public static int[] set_min_val( int[] a, int k )
{
int i;
for (i = 0; i < a.length; i++) {
if (a[i] < k) {
a[i] = k;
}
}
return a;
}
public static int get_array_value( int[] a, int k )
{
if (k - 1 >= a.length || k - 1 < 0) {
return -100000;
} else {
return a[k - 1];
}
}
public static int find_min( int[] a )
{
int min = a[0];
int i;
for (i = 0; i < a.length; i++) {
if (a[i] < min) {
min = a[i];
}
}
return min;
}
public static int[] find_diff( int[] a, int[] b )
{
int i;
int[] c = new int[a.length];
for (i = 0; i < a.length; i++) {
c[i] = a[i] - b[i];
}
return c;
}
public static int[] array_copy( int[] a )
{
int i;
int[] b = new int[a.length];
for (i = 0; i < a.length; i++) {
b[i] = a[i];
}
return b;
}
public static double find_euc_dist( int[] a, int[] b )
{
int i;
double sum = 0;
for (i = 0; i < a.length; i++) {
sum += (a[i] - b[i]) * (a[i] - b[i]);
}
double result = Math.sqrt( sum );
return result;
}
public static double find_magnitude( int[] a )
{
int i;
double sum = 0;
for (i = 0; i < a.length; i++) {
sum += a[i] * a[i];
}
double result = Math.sqrt( sum );
return result;
}
public static double manhattan_dist( int[] a, int[] b )
{
int i;
double sum = 0;
for (i = 0; i < a.length; i++) {
sum += Math.abs( a[i] - b[i] );
}
return sum;
}
public static double average( int[] a )
{
double sum = 0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
}
return sum / a.length;
}
public static int[] dec_array( int[] a, int k )
{
int i;
for (i = 0; i < a.length; i++) {
a[i] -= k;
}
return a;
}
public static double expr1( double a, double b )
{
double result = (b - a) / a;
return result;
}
public static int find_max( int[] a )
{
int max = a[0];
for (int i = 0; i < a.length; i++) {
if (a[i] > max) {
max = a[i];
}
}
return max;
}
public static int find_max2( int[] a )
{
int max = a[0] + a[1];
for (int i = 0; i < a.length - 1; i++) {
if (a[i] + a[i + 1] > max) {
max = a[i] + a[i + 1];
}
}
return max;
}
public static double variance( double[] x )
{
double sum = 0;
double sum1 = 0;
double var = 0;
double avrg = 0;
for (int i = 0; i < x.length; i++) {
sum = sum + x[i];
}
avrg = sum / (double) x.length;
for (int i = 0; i < x.length; i++) {
sum1 = sum1 + (x[i] - avrg) * (x[i] - avrg);
}
var = sum1 / (double) x.length;
return var;
}
public static int[] insertion_sort( int[] array )
{
for (int i = 1; i < array.length; i++) {
int j = i;
int B = array[i];
while (j > 0 && array[j - 1] > B) {
array[j] = array[j - 1];
j--;
}
array[j] = B;
}
return array;
}
public static double geometric_mean( int[] a )
{
long product = 1;
for (int i = 0; i < a.length; i++) {
product *= a[i];
}
return Math.pow( product, (double) 1 / a.length );
}
public static double mean_absolute_error( int[] a, int[] b )
{
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum += Math.abs( a[i] - b[i] );
}
return (double) sum / a.length;
}
public static double find_median( int[] a )
{
int k = a.length / 2 + 1;
int minIndex = 0;
int minValue = a[0];
for (int i = 0; i < k; i++) {
minIndex = i;
minValue = a[i];
for (int j = i + 1; j < a.length; j++) {
if (a[j] < minValue) {
minIndex = j;
minValue = a[j];
}
}
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
if (a.length % 2 == 0) {
return (double) (a[a.length / 2 - 1] + a[a.length / 2]) / 2;
} else {
return a[a.length / 2];
}
}
public static int[][] cartesian_product( int[] a, int[] b )
{
int[][] result = new int[a.length * b.length][2];
int cnt = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < b.length; j++) {
result[cnt][0] = a[i];
result[cnt][1] = b[j];
cnt++;
}
}
return result;
}
public static int[] reverse( int[] a )
{
int[] r = new int[a.length];
int cnt = 0;
for (int i = a.length - 1; i >= 0; i--) {
r[cnt] = a[i];
cnt++;
}
return r;
}
public static boolean check_equal_tolerance( double[] a, double[] b, double tol )
{
if (a.length != b.length) {
return false;
}
for (int i = 0; i < a.length; i++) {
if (Math.abs( a[i] - b[i] ) >= tol) {
return false;
}
}
return true;
}
public static boolean check_equal( int[] a, int[] b )
{
if (a.length != b.length) {
return false;
}
for (int i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
public static double weighted_average( double[] a, double[] b )
{
double sum1 = 0;
double sum2 = 0;
for (int i = 0; i < a.length; i++) {
sum1 += a[i] * b[i];
sum2 += b[i];
}
return sum1 / sum2;
}
public static int count_k( int[] a, int k )
{
int cnt = 0;
for (int i = 0; i < a.length; i++) {
if (a[i] == k) {
cnt++;
}
}
return cnt;
}
public static int[] clip( int[] a, int lowerLim, int upperLim )
{
int[] r = new int[a.length];
for (int i = 0; i < a.length; i++) {
if (a[i] < lowerLim) {
r[i] = lowerLim;
} else {
if (a[i] > upperLim) {
r[i] = upperLim;
} else {
r[i] = a[i];
}
}
}
return r;
}
public static int[] elementwise_max( int[] a, int[] b )
{
int[] r = new int[a.length];
for (int i = 0; i < a.length; i++) {
if (a[i] > b[i]) {
r[i] = a[i];
} else {
r[i] = b[i];
}
}
return r;
}
public static int[] elementwise_min( int[] a, int[] b )
{
int[] r = new int[a.length];
for (int i = 0; i < a.length; i++) {
if (a[i] < b[i]) {
r[i] = a[i];
} else {
r[i] = b[i];
}
}
return r;
}
public static int count_non_zeroes( int[] a )
{
int cnt = 0;
for (int i = 0; i < a.length; i++) {
if (a[i] != 0) {
cnt++;
}
}
return cnt;
}
public static int cnt_zeroes( int[] a )
{
int cnt = 0;
for (int i = 0; i < a.length; i++) {
if (a[i] == 0) {
cnt++;
}
}
return cnt;
}
public static boolean[] elementwise_equal( int[] a, int[] b )
{
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i++) {
if (a[i] == b[i]) {
r[i] = true;
} else {
r[i] = false;
}
}
return r;
}
public static boolean[] elementwise_not_equal( int[] a, int[] b )
{
boolean[] r = new boolean[a.length];
for (int i = 0; i < a.length; i++) {
if (a[~i] != b[i]) {
r[i] = true;
} else {
r[i] = false;
}
}
return r;
}
public static int hamming_dist( int[] a, int[] b )
{
int cnt = 0;
for (int i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
cnt++;
}
}
return cnt;
}
}
|
[
"[email protected]"
] | |
29125b55358823e9f5f169f10cfb17576b6631d9
|
bd518c1337430b63f29fcb82b3837d58bb4c82da
|
/KinematicsHelp/Car.java
|
e972e5e71213f448ba9b144ddb2cb83a236e5694
|
[] |
no_license
|
trackman1111/EngrGroup23
|
5188da77f1bc5ad36f8d65f5448dd92eed56d66d
|
652a88ec82d1af5bc2f94f98341b8a174ba4393a
|
refs/heads/master
| 2020-08-19T02:31:51.931705 | 2019-11-21T21:02:46 | 2019-11-21T21:02:46 | 215,865,475 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,829 |
java
|
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import javax.swing.*;
/**
* Write a description of class Car here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Car extends Actor
{
/**
* Act - do whatever the Car wants to do. This method is called whenever
* the 'Act' or 'Run' button gets pressed in the environment.
*/
private boolean checked = false;
private double inputVelocity;
private double displayVelocity = 12;
private double deccelerationValue;
private int initialX = 100;
private boolean hasMadeSound;
private GreenfootSound fastBrakeSound;
private GreenfootSound slowBrakeSound;
public Car()
{
GreenfootImage image = getImage();
image.scale(image.getWidth() * 2, image.getHeight() * 2);
hasMadeSound = false;
fastBrakeSound = new GreenfootSound("cars046.wav");
slowBrakeSound = new GreenfootSound("cars047.wav");
}
public void act()
{ if (!checked)
{
checkVelocity();
}
else
{
if ( displayVelocity > 0 )
{
move((int)displayVelocity);
displayVelocity -= .1 + (deccelerationValue/inputVelocity);
if ( !hasMadeSound && (deccelerationValue/inputVelocity) > .2 )
{
fastBrakeSound.play();
hasMadeSound = true;
}
else if( !hasMadeSound )
{
slowBrakeSound.play();
hasMadeSound = true;
}
}
else
{
calculateBrakingDistance(inputVelocity, deccelerationValue);
getWorld().addObject(new Button2(3), 300, 200);
fastBrakeSound.stop();
slowBrakeSound.stop();
}
}
}
public double checkVelocity()
{
try
{
inputVelocity = Double.parseDouble(JOptionPane.showInputDialog("Please input a velocity in meters per second"));
deccelerationValue = Double.parseDouble(JOptionPane.showInputDialog("Please input a decceleration value in meters per second"));
checked = true;
}
catch(Exception e)
{
checked = false;
JOptionPane.showMessageDialog(null, "Please Enter Valid Input");
}
return inputVelocity;
}
public void calculateBrakingDistance(double velocity, double decceleration)
{
double time = velocity / decceleration;
double distance = (.5 * velocity * time );
getWorld().showText("Time to stop: " + time + " seconds \nDistance traveled: " + distance + " meters", 300, 300);
}
}
|
[
"[email protected]"
] | |
533a13f51a3532c9036c378fea22931870b0d728
|
35aaddadff1fc6c639869bf7302d6927c0b1918a
|
/src/_310.java
|
0595e9b5739e5a6ab9b97a9039500c063e000c68
|
[] |
no_license
|
lydxlx1/LeetCode
|
daa3ceadf8c12d57a16ef2ce1a98216123d6b10a
|
516d5f08fc9b1b71b14d43687221a06d07dc51fc
|
refs/heads/master
| 2023-02-18T05:58:23.481713 | 2023-02-12T21:04:46 | 2023-02-12T21:04:46 | 46,915,247 | 110 | 48 | null | 2021-09-13T21:11:37 | 2015-11-26T08:58:18 |
Java
|
UTF-8
|
Java
| false | false | 2,518 |
java
|
import java.util.*;
/**
* LeetCode 310 - Minimum Height Trees
*
* It is easy to see that the root of an MHT has to be the middle point (or two middle points) of the longest path of the tree.
* Though multiple longest paths can appear in an unrooted tree, they must share the same middle point(s).
*
* Computing the longest path of a unrooted tree can be done, in O(n) time, by tree dp, or simply 2 tree traversals (dfs or bfs).
* The following code does the latter.
*
* Randomly select a node x as the root, do a dfs/bfs to find the node y that has the longest distance from y.
* Then y must be one of the endpoints on some longest path.
* Let y the new root, and do another dfs/bfs. Find the node z that has the longest distance from y.
*
* Now, the path from y to z is the longest one, and thus its middle point(s) is the answer.
*/
public class _310 {
int n;
List<Integer>[] e;
private void bfs(int start, int[] dist, int[] pre) {
boolean[] visited = new boolean[n];
Queue<Integer> queue = new ArrayDeque<>();
queue.add(start);
dist[start] = 0;
visited[start] = true;
pre[start] = -1;
while (!queue.isEmpty()) {
int u = queue.poll();
for (int v : e[u])
if (!visited[v]) {
visited[v] = true;
dist[v] = dist[u] + 1;
queue.add(v);
pre[v] = u;
}
}
}
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
if (n <= 0) return new ArrayList<>();
this.n = n;
e = new List[n];
for (int i = 0; i < n; i++)
e[i] = new ArrayList<>();
for (int[] pair : edges) {
int u = pair[0];
int v = pair[1];
e[u].add(v);
e[v].add(u);
}
int[] d1 = new int[n];
int[] d2 = new int[n];
int[] pre = new int[n];
bfs(0, d1, pre);
int u = 0;
for (int i = 0; i < n; i++)
if (d1[i] > d1[u]) u = i;
bfs(u, d2, pre);
int v = 0;
for (int i = 0; i < n; i++)
if (d2[i] > d2[v]) v = i;
List<Integer> list = new ArrayList<>();
while (v != -1) {
list.add(v);
v = pre[v];
}
if (list.size() % 2 == 1) return Arrays.asList(list.get(list.size() / 2));
else return Arrays.asList(list.get(list.size() / 2 - 1), list.get(list.size() / 2));
}
}
|
[
"[email protected]"
] | |
5da36a2d71340da2726f80b4ec51f3b3f537e200
|
b7b017a04a5a53902b9e69e527bde6bb48ececff
|
/app/src/test/java/com/flz/demonfc/ExampleUnitTest.java
|
19e91102ee44bacba46c55c4c4e128439e15fe7f
|
[] |
no_license
|
fanlingze/DemoNFC
|
a8a02f889d06b94d1f2a1ec176049ad7f6f6df61
|
e83af7f79743cfaeb626e308b7326f315e83bf0f
|
refs/heads/master
| 2020-03-19T07:39:41.844309 | 2018-06-05T08:08:24 | 2018-06-05T08:08:24 | 136,136,952 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 376 |
java
|
package com.flz.demonfc;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
}
|
[
"[email protected]"
] | |
f35c539da3910b610ac7446ea28599e03603073c
|
969e721f9524d135247c76095a381b460c50a36c
|
/hystrix-dashborad/src/test/java/com/june/hystrixdashborad/HystrixDashboradApplicationTests.java
|
43a3ae225bac47477c8824f9f9fc7890390d34f7
|
[] |
no_license
|
bks1000/stspringcloud
|
3828535067072ffa1ea2d7dc6f3dc9166b74928c
|
f9e04080552be992e5b2fdfc870470c4f5d617ab
|
refs/heads/master
| 2020-03-21T21:55:52.260139 | 2018-08-02T01:54:56 | 2018-08-02T01:54:56 | 139,093,944 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 352 |
java
|
package com.june.hystrixdashborad;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class HystrixDashboradApplicationTests {
@Test
public void contextLoads() {
}
}
|
[
"[email protected]"
] | |
84ee28314a3f9033a2b660c42c5a416679172bd0
|
7b4fd58090aa7013137ba2734d7f256b812861e1
|
/src/Ellias/rm/com/pay/buyManager/k.java
|
955092c0acec2e9035b89b392e56bf5576557952
|
[] |
no_license
|
daihuabin/Ellias
|
e37798a6a2e63454f80de512319ece885b6a2237
|
fd010991a5677e6aa104b927b82fc3d6da801887
|
refs/heads/master
| 2023-03-16T21:12:33.908495 | 2020-02-10T15:42:22 | 2020-02-10T15:42:22 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,697 |
java
|
package com.pay.buyManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import com.pay.data.buyInfo.APBuyQBInfo;
import com.pay.data.buyInfo.APBuyQDInfo;
import com.pay.tool.APDataInterface;
import com.pay.tool.APDataReportManager;
import com.pay.ui.common.APUICommonMethod;
import com.pay.ui.saveAccount.APSaveAccountListNumActivity;
final class k
implements DialogInterface.OnClickListener
{
k(APPayManager paramAPPayManager, int paramInt)
{
}
public final void onClick(DialogInterface paramDialogInterface, int paramInt)
{
APDataReportManager.getInstance().insertData("sdk.notenough.sure", this.a.saveType, null, String.valueOf(this.b), null);
if (this.b == 0)
{
APDataInterface.singleton().getOrderInfo().saveType = 2;
APDataInterface.singleton().getOrderInfo().buyInfo = new APBuyQDInfo();
APDataReportManager.getInstance().insertData("sdk.notenough.sure", this.a.saveType, null, "0", null);
}
while (true)
{
APUICommonMethod.popActivity();
Intent localIntent = new Intent();
localIntent.setClass(this.a.context, APSaveAccountListNumActivity.class);
this.a.context.startActivity(localIntent);
return;
APDataInterface.singleton().getOrderInfo().saveType = 3;
APDataInterface.singleton().getOrderInfo().buyInfo = new APBuyQBInfo();
APDataReportManager.getInstance().insertData("sdk.notenough.sure", this.a.saveType, null, "11", null);
}
}
}
/* Location: D:\rm_src\classes_dex2jar\
* Qualified Name: com.pay.buyManager.k
* JD-Core Version: 0.6.0
*/
|
[
"[email protected]"
] | |
0d18d3b6b70e69ff49e88945006031d06ab649a3
|
270e2f02c8ceceb0d8538bcbbf54ca7ab14004db
|
/eclipse-enterprise-workspace/DAT108_Oblig3/src/no/hvl/dat108/DeltakerEAO.java
|
dbfb0eb68d58ea8bafb3dc5b9c5136b6a581f036
|
[] |
no_license
|
arnekva/DAT108_Oblig3
|
54a9f71593a51e7b81f21399bfceafbe4afc9ba3
|
b81a3fb1b83962f327e004dbcb346eb35eb81c93
|
refs/heads/master
| 2020-04-07T08:27:13.350980 | 2018-11-19T12:00:48 | 2018-11-19T12:00:48 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 756 |
java
|
package no.hvl.dat108;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
@Stateless
public class DeltakerEAO {
@PersistenceContext(name = "deltakerPU")
private EntityManager em;
public synchronized void leggTilDeltaker(Deltaker deltaker) {
em.persist(deltaker);
}
public Deltaker hentDeltakerPaaPK(int mobilnr) {
return (Deltaker) em.find(Deltaker.class, mobilnr);
}
public List<Deltaker> hentAlleDeltakere() {
List<Deltaker> deltakere = null;
TypedQuery<Deltaker> query = em.createQuery("SELECT e FROM Deltaker e", Deltaker.class);
deltakere = query.getResultList();
return deltakere;
}
}
|
[
"[email protected]"
] | |
b5a722337e5027d7d6b8bbb084d6c2861ba58b79
|
ce734eb87049df497108b136da2a9450c4afec58
|
/customer-point/src/main/java/com/somecode/customer/point/bean/CustomerOperatorResult.java
|
1a9ba71d137492adbf19bcb287a3966c1516c3c8
|
[] |
no_license
|
zhikun-wang/rule-engine
|
14df78c907e013f79b8cbc979d0c4aa1775f0735
|
fdd30dc2eaeb93da320f3c6e66281b5e4a122141
|
refs/heads/master
| 2021-06-11T13:03:08.461428 | 2016-12-06T23:57:46 | 2016-12-06T23:57:46 | 75,777,819 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 934 |
java
|
package com.somecode.customer.point.bean;
import java.util.Date;
//流水记录
public class CustomerOperatorResult {
private Long id;
private Long carId;
private OperatorType operatorType;
private int adjustPoint;// 调整的分数，可以为负数
private Date createDate;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public OperatorType getOperatorType() {
return operatorType;
}
public void setOperatorType(OperatorType operatorType) {
this.operatorType = operatorType;
}
public int getAdjustPoint() {
return adjustPoint;
}
public void setAdjustPoint(int adjustPoint) {
this.adjustPoint = adjustPoint;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public Long getCarId() {
return carId;
}
public void setCarId(Long carId) {
this.carId = carId;
}
}
|
[
"[email protected]"
] | |
defa6d3144ebc721f8d72414542033d3966d7855
|
7fadba18351256e1fe58ba5a3e24d28d3d48c4d1
|
/src/main/java/org/springframework/security/oauth2/provider/endpoint/WhitelabelApprovalEndpoint.java
|
0cd6a913a160d2015b674981ed813601e19c8a82
|
[] |
no_license
|
szdksconan/oauth2.0
|
cb2644a78aad48221aa99da56894efcde79d26bc
|
c8f738c2210bf37d776bbd2483941ec4e17f55bb
|
refs/heads/master
| 2021-05-08T17:29:36.008867 | 2018-01-30T08:05:39 | 2018-01-30T08:05:39 | 119,474,969 | 1 | 4 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,355 |
java
|
package org.springframework.security.oauth2.provider.endpoint;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
/**
* Controller for displaying the approval page for the authorization server.
*
* @author Dave Syer
*/
@FrameworkEndpoint
@SessionAttributes("authorizationRequest")
public class WhitelabelApprovalEndpoint {
@RequestMapping("/oauth/confirm_access")
public ModelAndView getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
String template = createTemplate(model, request);
if (request.getAttribute("_csrf") != null) {
model.put("_csrf", request.getAttribute("_csrf"));
}
System.out.println(template);
return new ModelAndView(new SpelView(template), model);
}
protected String createTemplate(Map<String, Object> model, HttpServletRequest request) {
String template = TEMPLATE;
if (model.containsKey("scopes") || request.getAttribute("scopes") != null) {
template = template.replace("%scopes%", createScopes(model, request)).replace("%denial%", "");
}
else {
template = template.replace("%scopes%", "").replace("%denial%", DENIAL);
}
if (model.containsKey("_csrf") || request.getAttribute("_csrf") != null) {
template = template.replace("%csrf%", CSRF);
}
else {
template = template.replace("%csrf%", "");
}
return template;
}
private CharSequence createScopes(Map<String, Object> model, HttpServletRequest request) {
StringBuilder builder = new StringBuilder("<ul>");
@SuppressWarnings("unchecked")
Map<String, String> scopes = (Map<String, String>) (model.containsKey("scopes") ? model.get("scopes") : request
.getAttribute("scopes"));
for (String scope : scopes.keySet()) {
String approved = "true".equals(scopes.get(scope)) ? " checked" : "";
String denied = !"true".equals(scopes.get(scope)) ? " checked" : "";
String value = SCOPE.replace("%scope%", scope).replace("%key%", scope).replace("%approved%", approved)
.replace("%denied%", denied);
builder.append(value);
}
builder.append("</ul>");
return builder.toString();
}
private static String CSRF = "<input type='hidden' name='${_csrf.parameterName}' value='${_csrf.token}' />";
private static String DENIAL = "<form id='denialForm' name='denialForm' action='${path}/oauth/authorize' method='post'><input name='user_oauth_approval' value='false' type='hidden'/>%csrf%<label><input name='deny' value='Deny' type='submit'/></label></form>";
private static String TEMPLATE = "<html><body><h1>OAuth Approval</h1>"
+ "<p>Do you authorize '${authorizationRequest.clientId}' to access your protected resources?</p>"
+ "<form id='confirmationForm' name='confirmationForm' action='${path}/oauth/authorize' method='post'><input name='user_oauth_approval' value='true' type='hidden'/>%csrf%%scopes%<label><input name='authorize' value='Authorize' type='submit'/></label></form>"
+ "%denial%</body></html>";
private static String SCOPE = "<li><div class='form-group'>%scope%: <input type='radio' name='%key%'"
+ " value='true'%approved%>Approve</input> <input type='radio' name='%key%' value='false'%denied%>Deny</input></div></li>";
}
|
[
"[email protected]"
] | |
d33dc9f10e1ee421d9a9d76372c58331f90487a7
|
5cd9ff96d14fc98dfa9e0284e7d72598d44cfb0d
|
/gobblin-utility/src/test/java/org/apache/gobblin/util/AvroFlattenerTest.java
|
521bda2779413419d49e773bfa401a6baba3b732
|
[
"Apache-2.0",
"MIT"
] |
permissive
|
Flipkart/incubator-gobblin
|
3b43dcfde91c61e865845ad86673320f39bf73da
|
9aed23f7ac17cb461b35837ffb901d145cfeb11b
|
refs/heads/master
| 2022-07-20T00:05:26.748693 | 2020-05-22T04:39:52 | 2020-05-22T04:39:52 | 266,032,737 | 2 | 0 |
Apache-2.0
| 2020-05-22T06:12:11 | 2020-05-22T06:12:11 | null |
UTF-8
|
Java
| false | false | 5,972 |
java
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.gobblin.util;
import java.io.IOException;
import org.apache.avro.Schema;
import org.testng.Assert;
import org.testng.annotations.Test;
public class AvroFlattenerTest {
private static Schema readSchemaFromJsonFile(String filename)
throws IOException {
return new Schema.Parser()
.parse(AvroFlattenerTest.class.getClassLoader().getResourceAsStream("flattenAvro/" + filename));
}
/**
* Test flattening for Record within another Record
* Record R1 {
* fields: { Record R2 }
* }
*/
@Test
public void testRecordWithinRecord() throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for Record within Record within another Record
* Record R1 {
* fields:
* { Record R2
* fields:
* {
* Record R3
* }
* }
* }
*/
@Test
public void testRecordWithinRecordWithinRecord() throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinRecordWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinRecordWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for Record within an Option within another Record
* Record R1 {
* fields: { Union [ null, Record R2 ] }
* }
*/
@Test
public void testRecordWithinOptionWithinRecord () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinOptionWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinOptionWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for Record within an Union within another Record
* Record R1 {
* fields: { Union [ Record R2, null ] }
* }
*/
@Test
public void testRecordWithinUnionWithinRecord () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinUnionWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinUnionWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for Option within an Option within another Record
* Record R1 {
* fields: {
* Union [ null,
* Record 2 {
* fields: { Union [ null, Record 3] }
* }
* ]
* }
* }
*/
@Test
public void testOptionWithinOptionWithinRecord () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("optionWithinOptionWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("optionWithinOptionWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for a Record within Array within Array
* (no flattening should happen)
* Array A1 {
* [
* Array A2 {
* [
* Record R1
* ]
* }
* ]
* }
*/
@Test
public void testRecordWithinArrayWithinArray () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinArrayWithinArray_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinArrayWithinArray_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for an Array within Record within Array within Record
* (no flattening should happen)
* Record R1 {
* fields: { [
* Array A1 {
* [
* Record R2 {
* fields: { [
* Array A2
* ] }
* }
* ]
* }
* ] }
* }
*/
@Test
public void testArrayWithinRecordWithinArrayWithinRecord () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("arrayWithinRecordWithinArrayWithinRecord_original.json");
Schema expectedSchema = readSchemaFromJsonFile("arrayWithinRecordWithinArrayWithinRecord_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
/**
* Test flattening for a Record within Map within Map
* (no flattening should happen)
* Map M1 {
* values: {
* Map M2 {
* values: {
* Record R1
* }
* }
* }
* }
*/
@Test
public void testRecordWithinMapWithinMap () throws IOException {
Schema originalSchema = readSchemaFromJsonFile("recordWithinMapWithinMap_original.json");
Schema expectedSchema = readSchemaFromJsonFile("recordWithinMapWithinMap_flattened.json");
Assert.assertEquals(new AvroFlattener().flatten(originalSchema, false), expectedSchema);
}
}
|
[
"[email protected]"
] | |
e669171c3b5a9fe117e53df5d61fdfe2a80bab8c
|
8b691d354a6b647c5b804a43ccd616d736d01dac
|
/2019年4月14日.java
|
ade0ecb79a68322d1c47fb85bd876933b3a66545
|
[] |
no_license
|
xlwreally/JAVA
|
ecdc66a9008ee32ef9f235103c0d53f76604335f
|
525bf05768df8f94f45fcb28b56df8d87cbc2600
|
refs/heads/master
| 2020-05-09T16:20:55.986731 | 2019-04-14T06:13:17 | 2019-04-14T06:13:17 | 181,267,692 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 191 |
java
|
package 你好;
public class dfas {
public static void main(String[] args) {
int a=1,b=2;
while(a==1)
{
b+=100000;
System.out.println("你们好鸭");
}
}
}
|
[
"[email protected]"
] | |
01b55d60ac772f457ef59ec47434b192abe1e1a2
|
329f479ca2ec975fc7c45a001e1a2072b17747e3
|
/orderDetails/src/main/java/com/nagp/orderDetails/dto/Response.java
|
54486014975baba0dbf7b083176539f61753db86
|
[] |
no_license
|
anmol4210/microservices
|
b68ea9d8ad65e1c2b2f290d01e6ec13473124eea
|
eca469d8f470a279676672bea52cc237ef3991ac
|
refs/heads/master
| 2021-05-20T23:40:08.562628 | 2020-05-12T19:48:03 | 2020-05-12T19:48:03 | 252,455,983 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 456 |
java
|
package com.nagp.orderDetails.dto;
public class Response<T> {
private int status;
private T data;
private String message;
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
|
[
"[email protected]"
] | |
167eaeeba14d61ea8f7d02ec5f0c33bd88a9f369
|
9a52fe3bcdd090a396e59c68c63130f32c54a7a8
|
/sources/com/google/android/gms/common/data/BitmapTeleporter.java
|
1b6e2abf3e1630b49e034757c936141b4af2e9e5
|
[] |
no_license
|
mzkh/LudoKing
|
19d7c76a298ee5bd1454736063bc392e103a8203
|
ee0d0e75ed9fa8894ed9877576d8e5589813b1ba
|
refs/heads/master
| 2022-04-25T06:08:41.916017 | 2020-04-14T17:00:45 | 2020-04-14T17:00:45 | 255,670,636 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 6,611 |
java
|
package com.google.android.gms.common.data;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.ParcelFileDescriptor.AutoCloseInputStream;
import android.os.Parcelable.Creator;
import android.util.Log;
import com.google.android.gms.common.annotation.KeepForSdk;
import com.google.android.gms.common.internal.ReflectedParcelable;
import com.google.android.gms.common.internal.ShowFirstParty;
import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable.Class;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable.Constructor;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable.Field;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable.Param;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable.VersionField;
import com.google.android.gms.drive.DriveFile;
import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
@ShowFirstParty
@KeepForSdk
@Class(creator = "BitmapTeleporterCreator")
public class BitmapTeleporter extends AbstractSafeParcelable implements ReflectedParcelable {
@KeepForSdk
public static final Creator<BitmapTeleporter> CREATOR = new zaa();
@Field(mo15151id = 3)
private final int mType;
@VersionField(mo15157id = 1)
private final int zalf;
@Field(mo15151id = 2)
private ParcelFileDescriptor zalg;
private Bitmap zalh;
private boolean zali;
private File zalj;
@Constructor
BitmapTeleporter(@Param(mo15154id = 1) int i, @Param(mo15154id = 2) ParcelFileDescriptor parcelFileDescriptor, @Param(mo15154id = 3) int i2) {
this.zalf = i;
this.zalg = parcelFileDescriptor;
this.mType = i2;
this.zalh = null;
this.zali = false;
}
@KeepForSdk
public BitmapTeleporter(Bitmap bitmap) {
this.zalf = 1;
this.zalg = null;
this.mType = 0;
this.zalh = bitmap;
this.zali = true;
}
@KeepForSdk
public Bitmap get() {
if (!this.zali) {
DataInputStream dataInputStream = new DataInputStream(new AutoCloseInputStream(this.zalg));
try {
byte[] bArr = new byte[dataInputStream.readInt()];
int readInt = dataInputStream.readInt();
int readInt2 = dataInputStream.readInt();
Config valueOf = Config.valueOf(dataInputStream.readUTF());
dataInputStream.read(bArr);
zaa(dataInputStream);
ByteBuffer wrap = ByteBuffer.wrap(bArr);
Bitmap createBitmap = Bitmap.createBitmap(readInt, readInt2, valueOf);
createBitmap.copyPixelsFromBuffer(wrap);
this.zalh = createBitmap;
this.zali = true;
} catch (IOException e) {
throw new IllegalStateException("Could not read from parcel file descriptor", e);
} catch (Throwable th) {
zaa(dataInputStream);
throw th;
}
}
return this.zalh;
}
public void writeToParcel(Parcel parcel, int i) {
if (this.zalg == null) {
Bitmap bitmap = this.zalh;
ByteBuffer allocate = ByteBuffer.allocate(bitmap.getRowBytes() * bitmap.getHeight());
bitmap.copyPixelsToBuffer(allocate);
byte[] array = allocate.array();
DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(zabz()));
try {
dataOutputStream.writeInt(array.length);
dataOutputStream.writeInt(bitmap.getWidth());
dataOutputStream.writeInt(bitmap.getHeight());
dataOutputStream.writeUTF(bitmap.getConfig().toString());
dataOutputStream.write(array);
zaa(dataOutputStream);
} catch (IOException e) {
throw new IllegalStateException("Could not write into unlinked file", e);
} catch (Throwable th) {
zaa(dataOutputStream);
throw th;
}
}
int i2 = i | 1;
int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
SafeParcelWriter.writeInt(parcel, 1, this.zalf);
SafeParcelWriter.writeParcelable(parcel, 2, this.zalg, i2, false);
SafeParcelWriter.writeInt(parcel, 3, this.mType);
SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
this.zalg = null;
}
@KeepForSdk
public void release() {
if (!this.zali) {
try {
this.zalg.close();
} catch (IOException e) {
Log.w("BitmapTeleporter", "Could not close PFD", e);
}
}
}
@KeepForSdk
public void setTempDir(File file) {
if (file != null) {
this.zalj = file;
return;
}
throw new NullPointerException("Cannot set null temp directory");
}
private final FileOutputStream zabz() {
File file = this.zalj;
if (file != null) {
try {
File createTempFile = File.createTempFile("teleporter", ".tmp", file);
try {
FileOutputStream fileOutputStream = new FileOutputStream(createTempFile);
this.zalg = ParcelFileDescriptor.open(createTempFile, DriveFile.MODE_READ_ONLY);
createTempFile.delete();
return fileOutputStream;
} catch (FileNotFoundException unused) {
throw new IllegalStateException("Temporary file is somehow already deleted");
}
} catch (IOException e) {
throw new IllegalStateException("Could not create temporary file", e);
}
} else {
throw new IllegalStateException("setTempDir() must be called before writing this object to a parcel");
}
}
private static void zaa(Closeable closeable) {
try {
closeable.close();
} catch (IOException e) {
Log.w("BitmapTeleporter", "Could not close stream", e);
}
}
}
|
[
"[email protected]"
] | |
a255ea0a402439ed0d9954c4c3ce8c9d29403385
|
112ef2de944015b35f92a9bbf7ab4281f050ae0f
|
/leetCode/138CopyListWithRandomPointer.java
|
02f4fbcdcdc5fa5684bcf090ad41aa31a4b12ccd
|
[] |
no_license
|
erwenzhang/helloGit
|
139e355d640e686b594679dcc5a22fabd86f7c0d
|
d356350ab3c5af0892145f540782caa6cf7f9bd0
|
refs/heads/master
| 2020-04-06T06:54:24.786263 | 2016-10-28T04:12:47 | 2016-10-28T04:12:47 | 36,017,247 | 0 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 864 |
java
|
/**
* Definition for singly-linked list with a random pointer.
* class RandomListNode {
* int label;
* RandomListNode next, random;
* RandomListNode(int x) { this.label = x; }
* };
*/
public class Solution {
public RandomListNode copyRandomList(RandomListNode head){
RandomListNode dummyHead = new RandomListNode(-1);
RandomListNode p = dummyHead;
RandomListNode q = head;
HashMap<RandomListNode, RandomListNode> map = new HashMap<>();
while(q!=null){
p.next = new RandomListNode(q.label);
map.put(q, p.next);
p = p.next;
q = q.next;
}
q = head;
p = dummyHead;
while(q!=null){
p.next.random = map.get(q.random);
q = q.next;
p = p.next;
}
return dummyHead.next;
}
}
|
[
"[email protected]"
] | |
10cef24e08906525e1d3e897c0eea92ee083e0fa
|
6ca764ba606de760057bedcd65cadcf81543ebc2
|
/backend-server/src/main/java/com/greenhouse/demo/config/FilterConfig.java
|
ba491560c9bad60289cac5b92f945f2b77c3638c
|
[
"MIT"
] |
permissive
|
shilang/microservice-oauth-greenhouse
|
9d8e3f666c2aaa89f1e8e4a791acddf3ef99f8fb
|
c7d36ce5a366af73d61b4539d52a25f2c28160b0
|
refs/heads/master
| 2020-04-16T06:53:36.378780 | 2019-01-12T08:46:03 | 2019-01-12T08:46:03 | 165,364,944 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 5,000 |
java
|
package com.greenhouse.demo.config;
import com.greenhouse.demo.filter.AuthorizationFilter;
import com.sun.deploy.config.SecuritySettings;
import org.apache.commons.lang.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.hierarchicalroles.RoleHierarchy;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import java.util.Arrays;
/**
* Created by keets on 2017/12/6.
*/
@Configuration
@EnableAutoConfiguration
public class FilterConfig {
@Bean
public FilterRegistrationBean filterRegistrationBean() {
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setFilter(authorizationFilter());
registrationBean.setOrder(0);
return registrationBean;
}
@Bean
public AuthorizationFilter authorizationFilter() {
return new AuthorizationFilter();
}
@EnableWebSecurity
@EnableConfigurationProperties(SecurityProperties.class)
public static class WebSecurityConfigurer extends WebSecurityConfigurerAdapter {
// Customized SecuritySettings
private final SecuritySettings securitySettings;
// Customized AuthenticationManager
private final AuthenticationManager authenticationManager;
// Customized Filter 1
private final JwtAuthenticationFilter jwtAuthenticationFilter;
// Customized Filter 2
private final BusinessFilterSecurityInterceptor businessFilterSecurityInterceptor;
@Autowired
public WebSecurityConfigurer(SecuritySettings securitySettings, WebUriRoleService uriRoleService,
AuthenticationManager authenticationManager, RoleHierarchy roleHierarchy, CacheManager redis, UserDataCollector udc) {
super(true);
this.securitySettings = securitySettings;
this.authenticationManager = authenticationManager;
this.jwtAuthenticationFilter = new JwtAuthenticationFilter(authenticationManager, securitySettings, redis, udc);
this.businessFilterSecurityInterceptor = new BusinessFilterSecurityInterceptor(uriRoleService, roleHierarchy);
}
@Override
public AuthenticationManager authenticationManager() throws Exception {
return authenticationManager;
}
@Override
public void configure(HttpSecurity http) throws Exception {
if (ArrayUtils.isNotEmpty(securitySettings.getAllowedOrigins())) {
http.cors().configurationSource(getCorsSource()); // Cross-Origin Resource Sharing
}
http.exceptionHandling().disable(); // Let customized (GlobalExceptionController.java + GlobalExceptionHandler.java) handle it.
http.anonymous().disable();
http.rememberMe().disable();
http.sessionManagement().disable();
http.addFilterAfter(jwtAuthenticationFilter, CorsFilter.class); // Custom JWT based security filter
//http.authorizeRequests().anyRequest().authenticated(); // default FilterSecurityInterceptor
http.addFilterAfter(businessFilterSecurityInterceptor, JwtAuthenticationFilter.class); // Custom security interceptor after default
http.csrf().disable(); // disable csrf
http.headers().cacheControl(); // enable cache control
}
@Override
public void configure(WebSecurity web) throws Exception {
web.ignoring().antMatchers(securitySettings.getIgnorings());
}
private CorsConfigurationSource getCorsSource() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
CorsConfiguration config = new CorsConfiguration();
config.setMaxAge(securitySettings.getCorsMaxAgeInSeconds());
config.setAllowCredentials(securitySettings.getCorsAllowCredentials()); // you USUALLY want this
config.setAllowedOrigins(Arrays.asList(securitySettings.getAllowedOrigins()));
config.setAllowedHeaders(Arrays.asList("*"));
config.setAllowedMethods(Arrays.asList("GET", "POST", "OPTIONS"));
source.registerCorsConfiguration("/**", config);
return source;
}
}
}
|
[
"[email protected]"
] | |
8e91467b58ddfe6bfb763d1f3216354f79c1ecd4
|
7fb81e3e8f622b32b1f1a4f8ab8d875fa01d5901
|
/DiceRoller3/app/src/main/java/com/example/diceroller3/DiceScore.java
|
096508eb0e49f7285316181b0a854f3ea8357a3c
|
[] |
no_license
|
tparris4/AndroidProjects12412
|
190b473e937e28a3241ded46784b2bfac414c814
|
d2030228eed7bab52827555c6e5fe9e089f8d1dc
|
refs/heads/master
| 2022-06-21T16:43:34.492207 | 2020-05-06T04:15:47 | 2020-05-06T04:15:47 | 261,646,841 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,908 |
java
|
package com.example.diceroller3;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Button;
import android.widget.Toast;
public class DiceScore extends AppCompatActivity implements View.OnClickListener{
Button Player1;
Button Player2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_dice_score);
Intent intent = getIntent();
Bundle b2 = getIntent().getExtras();
int p1Score = intent.getIntExtra("Player 1 Score", 0);
int p2Score = intent.getIntExtra("Player 2 Score", 0);
TextView P1 = (TextView) findViewById(R.id.player_1);
P1.setText(b2.getInt("Player 1"));
TextView P2 = (TextView) findViewById(R.id.player_2);
P2.setText(b2.getInt("Player 2"));
//updateScore();
Player1 = (Button) findViewById(R.id.Button1);
Player1.setOnClickListener(DiceScore.this);
Player2 = (Button) findViewById(R.id.Button2);
Player2.setOnClickListener(DiceScore.this);
}
@Override
public void onClick(View v){
switch (v.getId()){
case R.id.Button1:
Toast.makeText(this, "Player 1 has" + String.valueOf("Player 1 Score") , Toast.LENGTH_LONG).show();
break;
case R.id.Button2:
Toast.makeText(this, "Player 2 has" + String.valueOf("Player 2 Score") , Toast.LENGTH_LONG).show();
break;
default:
break;
}
}
private void updateScore(){
}
public void goBack(View v){
this.finish();
}
}
|
[
"[email protected]"
] | |
e9defde037327b5ee64507eb4db76e92fa07a8f9
|
d0d6cc4502b46751961b272e4cf11e4bc014ac48
|
/src/p5/Ingreso.java
|
757689f3d8ab53f8f9f770c590cdd89d31c8e374
|
[] |
no_license
|
Juanma1979m/entreculturas
|
c2745eb14ce8e8b7e177a7ad43fd2217a2ff36f2
|
914575838bcd0789ae5e729ed65b907dc2632b63
|
refs/heads/master
| 2022-12-28T07:06:50.844653 | 2020-09-28T17:10:42 | 2020-09-28T17:10:42 | 299,377,154 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 896 |
java
|
package p5;
import java.util.Date;
import javax.xml.bind.annotation.*;
@XmlRootElement(name="ingreso")
@XmlAccessorType(XmlAccessType.FIELD)
public class Ingreso {
@XmlElement(name="ref")
private int ref;
@XmlElement(name="fecha")
private Date fecha;
@XmlElement(name="importe")
private float importe;
public Ingreso(int miRef, Date miFecha, float miImporte) {
ref = miRef;
fecha = miFecha;
importe = miImporte;
}
public int getRef() {
return ref;
}
public void setRef(int miRef) {
ref = miRef;
}
public Date getFecha() {
return fecha;
}
public void setFecha(Date miFecha) {
fecha = miFecha;
}
public float getImporte() {
return importe;
}
public void setImporte(float miImporte) {
importe = miImporte;
}
}
|
[
"[email protected]"
] | |
ef9be3a04630f43335c3fa5963b8206390162a90
|
ae3c62b7d2703a99675a26e96f9e07431bc5c84a
|
/bin/custom/fscomparisonaddon/acceleratoraddon/web/src/es/fs/fscomparisonaddon/controllers/pages/ComparisonController.java
|
cb2c69c2eebe0f397bf86d966be8d6dd53bfb4b9
|
[] |
no_license
|
WorldInnovation/comparison
|
afbae3ec668fc689a5d81a01f554ff2f9b5c50dd
|
ce667dfa6907df421605a8c700f6584fc2c28304
|
refs/heads/master
| 2021-01-16T05:54:31.424822 | 2020-02-25T15:24:34 | 2020-02-25T15:24:34 | 242,999,214 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,381 |
java
|
package es.fs.fscomparisonaddon.controllers.pages;
import de.hybris.platform.acceleratorstorefrontcommons.controllers.pages.AbstractPageController;
import de.hybris.platform.cms2.exceptions.CMSItemNotFoundException;
import de.hybris.platform.commercefacades.product.data.ProductData;
import es.fs.fscomparisonaddon.facades.ComparisonFacade;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Set;
@Controller
@RequestMapping("/comparison")
public class ComparisonController extends AbstractPageController
{
final String GET_COMPONENT_NAME = "Comparison";
final String GET_ADDON_JSP_PAGE_REFRESH =
"addon:" + "/" + "fscomparisonaddon" + "/" + "fragments" + "/" + "comparisonajaxcomponent";
final String GET_ADDON_JSP_PAGE_COMPARE =
"addon:" + "/" + "fscomparisonaddon" + "/" + "pages" + "/" + "comparisoncomparepage";
final String COMPARE_CMS_PAGE = "compare";
@Resource(name = "comparisonFacadeImpl")
private ComparisonFacade comparisonFacade;
@RequestMapping(value = "/add", method = RequestMethod.POST, params = "code")
@ResponseBody
public ProductData addComparison(@RequestParam("code") final String productCode)
{
return comparisonFacade.add(productCode);
}
@RequestMapping(value = "/get", method = RequestMethod.GET)
public String getComparisonData(final HttpServletRequest request, final Model model)
{
model.addAttribute("component", GET_COMPONENT_NAME);
return GET_ADDON_JSP_PAGE_REFRESH;
}
@RequestMapping(value = "/delete", method = RequestMethod.POST, params = "code")
@ResponseBody
public String deleteComparison(@RequestParam("code") final String categoryCode)
{
return comparisonFacade.deleteCategory(categoryCode);
}
@RequestMapping(value = "/compare/{categoryCode}", method = RequestMethod.GET)
public String compareComparison(final Model model, @PathVariable final String categoryCode)
throws CMSItemNotFoundException
{
Set<ProductData> compare = comparisonFacade.compare(categoryCode);
model.addAttribute("compare", compare);
storeCmsPageInModel(model, getContentPageForLabelOrId(COMPARE_CMS_PAGE));
setUpMetaDataForContentPage(model, getContentPageForLabelOrId(COMPARE_CMS_PAGE));
return getViewForPage(model);
}
}
|
[
"[email protected]"
] | |
53b585e1a081b17eed2d349f84ad310fbf4307a7
|
832a25d71428fcc97554ead3184c34c7668c13f6
|
/src/main/java/com/jeeplus/modules/ironfo_yjbylsbpz_pfk/entity/Ironfo_yjbylsbpz_pfk.java
|
9bc7c24091442a932860cfb2009c32ccf08a0d5b
|
[] |
no_license
|
wxbing2015/jeeplusS
|
bb3b2bc7e475a7042c9a147952008ca93de59feb
|
faf39d547fad5fad9ff0e046fd9a657f2202a886
|
refs/heads/master
| 2020-07-19T11:44:35.847707 | 2018-05-02T11:59:39 | 2018-05-02T11:59:39 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,056 |
java
|
/**
* Copyright © 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.jeeplus.modules.ironfo_yjbylsbpz_pfk.entity;
import com.jeeplus.common.persistence.DataEntity;
import com.jeeplus.common.utils.excel.annotation.ExcelField;
import com.jeeplus.modules.ironfodoctitle.entity.IronfoDocTitle;
import com.jeeplus.modules.sys.entity.User;
/**
* 皮肤科Entity
* @author mikesun
* @version 2018-03-22
*/
public class Ironfo_yjbylsbpz_pfk extends DataEntity<Ironfo_yjbylsbpz_pfk> {
private static final long serialVersionUID = 1L;
private String doc_id; // 主表id
private String sbmc; // 设备名称
private String pp; // 品牌
private String xh; // 型号
private String sl; // 数量（台/个）
private String sbjg; // 设备价格（元）
private String trsynf; // 投入使用年份
private User duser;
//add by anti_magina
private String duserName;
@ExcelField(title="用户", align=2, sort=6)
public String getDuserName() {
duserName = duser.getName();
return duserName;
}
public void setDuserName(String duserName) {
this.duserName = duserName;
}
private IronfoDocTitle ironfoDocTitle;
@ExcelField(title="设备名称", align=2, sort=8)
public String getSbmc() {
return sbmc;
}
public void setSbmc(String sbmc) {
this.sbmc = sbmc;
}
@ExcelField(title="品牌", align=2, sort=9)
public String getPp() {
return pp;
}
public void setPp(String pp) {
this.pp = pp;
}
@ExcelField(title="型号", align=2, sort=10)
public String getXh() {
return xh;
}
public void setXh(String xh) {
this.xh = xh;
}
@ExcelField(title="数量（台/个）", align=2, sort=11)
public String getSl() {
return sl;
}
public void setSl(String sl) {
this.sl = sl;
}
@ExcelField(title="设备价格（元）", align=2, sort=12)
public String getSbjg() {
return sbjg;
}
public void setSbjg(String sbjg) {
this.sbjg = sbjg;
}
@ExcelField(title="投入使用年份", align=2, sort=7)
public String getTrsynf() {
return trsynf;
}
public void setTrsynf(String trsynf) {
this.trsynf = trsynf;
}
public User getDuser() {
return duser;
}
public void setDuser(User duser) {
this.duser = duser;
}
public IronfoDocTitle getIronfoDocTitle() {
return ironfoDocTitle;
}
public void setIronfoDocTitle(IronfoDocTitle ironfoDocTitle) {
this.ironfoDocTitle = ironfoDocTitle;
}
public Ironfo_yjbylsbpz_pfk() {
super();
}
public Ironfo_yjbylsbpz_pfk(String id){
super(id);
}
//@ExcelField(title="主表id", align=2, sort=7)
public String getDoc_id() {
return doc_id;
}
public void setDoc_id(String doc_id) {
this.doc_id = doc_id;
}
// private static final long serialVersionUID = 1L;
// private String doc_id; // 主表id
// private String sbmc; // 设备名称
// private String pp; // 品牌
// private String xh; // 型号
// private String sl; // 数量（台/个）
// private String sbjg; // 设备价格（元）
// private String trsynf; // 投入使用年份
//
// public Ironfo_yjbylsbpz_pfk() {
// super();
// }
//
// public Ironfo_yjbylsbpz_pfk(String id){
// super(id);
// }
//
// @ExcelField(title="主表id", align=2, sort=7)
// public String getDoc_id() {
// return doc_id;
// }
//
// public void setDoc_id(String doc_id) {
// this.doc_id = doc_id;
// }
//
// public String getSbmc() {
// return sbmc;
// }
//
// public void setSbmc(String sbmc) {
// this.sbmc = sbmc;
// }
//
// public String getPp() {
// return pp;
// }
//
// public void setPp(String pp) {
// this.pp = pp;
// }
//
// public String getXh() {
// return xh;
// }
//
// public void setXh(String xh) {
// this.xh = xh;
// }
//
// public String getSl() {
// return sl;
// }
//
// public void setSl(String sl) {
// this.sl = sl;
// }
//
// public String getSbjg() {
// return sbjg;
// }
//
// public void setSbjg(String sbjg) {
// this.sbjg = sbjg;
// }
//
// public String getTrsynf() {
// return trsynf;
// }
//
// public void setTrsynf(String trsynf) {
// this.trsynf = trsynf;
// }
//
//
}
|
[
"[email protected]"
] | |
9c31edb1033c396258ab701437b310560769767c
|
7b6e5ff9b8f4b48d349becd8f93847a940a3957a
|
/src/main/java-gen/io/dronefleet/mavlink/ardupilotmega/LedControl.java
|
73b53af6b0adfc19944c4bb377cab9301cc76c14
|
[
"MIT"
] |
permissive
|
joelkoz/mavlink
|
c7888f4023fb7ac81e79820ebfebcf2a743f7de3
|
747f4b9a19fb4911f19df2f048d91ee01d5a8fc2
|
refs/heads/master
| 2020-03-31T19:10:20.328569 | 2018-10-10T21:23:09 | 2018-10-10T21:23:09 | 152,487,365 | 0 | 0 |
MIT
| 2018-10-10T20:43:32 | 2018-10-10T20:43:32 | null |
UTF-8
|
Java
| false | false | 6,890 |
java
|
package io.dronefleet.mavlink.ardupilotmega;
import io.dronefleet.mavlink.annotations.MavlinkFieldInfo;
import io.dronefleet.mavlink.annotations.MavlinkMessageBuilder;
import io.dronefleet.mavlink.annotations.MavlinkMessageInfo;
import java.lang.Object;
import java.lang.Override;
import java.lang.String;
import java.util.Objects;
/**
* Control vehicle LEDs
*/
@MavlinkMessageInfo(
id = 186,
crc = 72,
description = "Control vehicle LEDs"
)
public final class LedControl {
private final int targetSystem;
private final int targetComponent;
private final int instance;
private final int pattern;
private final int customLen;
private final byte[] customBytes;
private LedControl(int targetSystem, int targetComponent, int instance, int pattern,
int customLen, byte[] customBytes) {
this.targetSystem = targetSystem;
this.targetComponent = targetComponent;
this.instance = instance;
this.pattern = pattern;
this.customLen = customLen;
this.customBytes = customBytes;
}
/**
* Returns a builder instance for this message.
*/
@MavlinkMessageBuilder
public static Builder builder() {
return new Builder();
}
/**
* System ID
*/
@MavlinkFieldInfo(
position = 1,
unitSize = 1,
description = "System ID"
)
public final int targetSystem() {
return this.targetSystem;
}
/**
* Component ID
*/
@MavlinkFieldInfo(
position = 2,
unitSize = 1,
description = "Component ID"
)
public final int targetComponent() {
return this.targetComponent;
}
/**
* Instance (LED instance to control or 255 for all LEDs)
*/
@MavlinkFieldInfo(
position = 3,
unitSize = 1,
description = "Instance (LED instance to control or 255 for all LEDs)"
)
public final int instance() {
return this.instance;
}
/**
* Pattern (see LED_PATTERN_ENUM)
*/
@MavlinkFieldInfo(
position = 4,
unitSize = 1,
description = "Pattern (see LED_PATTERN_ENUM)"
)
public final int pattern() {
return this.pattern;
}
/**
* Custom Byte Length
*/
@MavlinkFieldInfo(
position = 5,
unitSize = 1,
description = "Custom Byte Length"
)
public final int customLen() {
return this.customLen;
}
/**
* Custom Bytes
*/
@MavlinkFieldInfo(
position = 6,
unitSize = 1,
arraySize = 24,
description = "Custom Bytes"
)
public final byte[] customBytes() {
return this.customBytes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || !getClass().equals(o.getClass())) return false;
LedControl other = (LedControl)o;
if (!Objects.deepEquals(targetSystem, other.targetSystem)) return false;
if (!Objects.deepEquals(targetComponent, other.targetComponent)) return false;
if (!Objects.deepEquals(instance, other.instance)) return false;
if (!Objects.deepEquals(pattern, other.pattern)) return false;
if (!Objects.deepEquals(customLen, other.customLen)) return false;
if (!Objects.deepEquals(customBytes, other.customBytes)) return false;
return true;
}
@Override
public int hashCode() {
int result = 0;
result = 31 * result + Objects.hashCode(targetSystem);
result = 31 * result + Objects.hashCode(targetComponent);
result = 31 * result + Objects.hashCode(instance);
result = 31 * result + Objects.hashCode(pattern);
result = 31 * result + Objects.hashCode(customLen);
result = 31 * result + Objects.hashCode(customBytes);
return result;
}
@Override
public String toString() {
return "LedControl{targetSystem=" + targetSystem
+ ", targetComponent=" + targetComponent
+ ", instance=" + instance
+ ", pattern=" + pattern
+ ", customLen=" + customLen
+ ", customBytes=" + customBytes + "}";
}
public static final class Builder {
private int targetSystem;
private int targetComponent;
private int instance;
private int pattern;
private int customLen;
private byte[] customBytes;
/**
* System ID
*/
@MavlinkFieldInfo(
position = 1,
unitSize = 1,
description = "System ID"
)
public final Builder targetSystem(int targetSystem) {
this.targetSystem = targetSystem;
return this;
}
/**
* Component ID
*/
@MavlinkFieldInfo(
position = 2,
unitSize = 1,
description = "Component ID"
)
public final Builder targetComponent(int targetComponent) {
this.targetComponent = targetComponent;
return this;
}
/**
* Instance (LED instance to control or 255 for all LEDs)
*/
@MavlinkFieldInfo(
position = 3,
unitSize = 1,
description = "Instance (LED instance to control or 255 for all LEDs)"
)
public final Builder instance(int instance) {
this.instance = instance;
return this;
}
/**
* Pattern (see LED_PATTERN_ENUM)
*/
@MavlinkFieldInfo(
position = 4,
unitSize = 1,
description = "Pattern (see LED_PATTERN_ENUM)"
)
public final Builder pattern(int pattern) {
this.pattern = pattern;
return this;
}
/**
* Custom Byte Length
*/
@MavlinkFieldInfo(
position = 5,
unitSize = 1,
description = "Custom Byte Length"
)
public final Builder customLen(int customLen) {
this.customLen = customLen;
return this;
}
/**
* Custom Bytes
*/
@MavlinkFieldInfo(
position = 6,
unitSize = 1,
arraySize = 24,
description = "Custom Bytes"
)
public final Builder customBytes(byte[] customBytes) {
this.customBytes = customBytes;
return this;
}
public final LedControl build() {
return new LedControl(targetSystem, targetComponent, instance, pattern, customLen, customBytes);
}
}
}
|
[
"[email protected]"
] | |
a0632444af18f640a587819b119346375a47eb31
|
a13db6045e9618efa2d3a6e76a005f48d30bc95c
|
/app/src/main/java/com/fdw/fdd/entity/bean/OrderDetailsBeans.java
|
bcf29dfaafd38eaeaa0fb87e4721de4e7db7db76
|
[] |
no_license
|
shf3063524/fuduoduo
|
27c0731a1f911f87d1143305a9cde09bbc77ed2f
|
7798479bbb3d3e24de6c5fde2dc86320908c238a
|
refs/heads/master
| 2020-09-06T08:32:11.983548 | 2019-11-28T02:58:24 | 2019-11-28T02:58:24 | 220,374,652 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,359 |
java
|
package com.fdw.fdd.entity.bean;
import java.io.Serializable;
/**
*
*/
public class OrderDetailsBeans implements Serializable {
private static final long serialVersionUID = -5973758491861960058L;
private String id;
private String ordersId;
private String commodityId;
private String commoditySpecificationId;
private String parentCategoryId;
private String price;
private String number;
private String activityId;
private String isState;
private String freightId;
private String totalPrice;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getOrdersId() {
return ordersId;
}
public void setOrdersId(String ordersId) {
this.ordersId = ordersId;
}
public String getCommodityId() {
return commodityId;
}
public void setCommodityId(String commodityId) {
this.commodityId = commodityId;
}
public String getCommoditySpecificationId() {
return commoditySpecificationId;
}
public void setCommoditySpecificationId(String commoditySpecificationId) {
this.commoditySpecificationId = commoditySpecificationId;
}
public String getParentCategoryId() {
return parentCategoryId;
}
public void setParentCategoryId(String parentCategoryId) {
this.parentCategoryId = parentCategoryId;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getActivityId() {
return activityId;
}
public void setActivityId(String activityId) {
this.activityId = activityId;
}
public String getIsState() {
return isState;
}
public void setIsState(String isState) {
this.isState = isState;
}
public String getFreightId() {
return freightId;
}
public void setFreightId(String freightId) {
this.freightId = freightId;
}
public String getTotalPrice() {
return totalPrice;
}
public void setTotalPrice(String totalPrice) {
this.totalPrice = totalPrice;
}
}
|
[
"[email protected]"
] | |
db10394428e6eeca13c8c720a72fa5084a591e8a
|
1b67a1ff37bf9d63a7cce3f2cb24b41bcb465d10
|
/FiscalApp/src/main/java/com/fiscalapp/fiscalapp/CategoriesFragment.java
|
a7055ffa6ac22d18320707d9db9865808d50b424
|
[] |
no_license
|
jkwlui/FiscalAppAndroid
|
964934d20f4c33ea3f7445cdadde488371922153
|
ff54514e0b9417af40dab9417e1f7078da50375c
|
refs/heads/master
| 2021-05-28T05:22:15.542350 | 2015-01-30T09:05:36 | 2015-01-30T09:05:36 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,581 |
java
|
package com.fiscalapp.fiscalapp;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ListView;
import com.fiscalapp.fiscalapp.adapter.CategoryListAdapter;
import com.fiscalapp.fiscalapp.database.TransactionDatabaseExchanger;
import com.fiscalapp.fiscalapp.model.Category;
import java.util.ArrayList;
/**
* Created by kinwa91 on 2014-03-11.
*/
public class CategoriesFragment extends Fragment{
public CategoriesFragment() {}
private ListView listView;
private CategoryListAdapter adapter;
private Button newCategoryButton;
private String displayType;
public static String CATEGORIES_MODE = "mode";
public static String CATEGORIES_ID = "editId";
public static String CATEGORIES_EDIT_MODE = "edit";
public CategoriesFragment(String displayType) {
super();
this.displayType = displayType;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_categories, container, false);
listView = (ListView) rootView.findViewById(R.id.categoriesListView);
// Add OnClickListener to New Category Button
newCategoryButton = (Button) rootView.findViewById(R.id.new_category_button);
Button.OnClickListener clickListener = new Button.OnClickListener() {
@Override
public void onClick(View view) {
Intent i = new Intent(getActivity(), NewCategory.class);
startActivityForResult(i,1);
}
};
newCategoryButton.setOnClickListener(clickListener);
displayList();
return rootView;
}
private void displayList() {
// Query Database using DatabaseExchanger
TransactionDatabaseExchanger dbExchanger = new TransactionDatabaseExchanger(getActivity());
dbExchanger.open();
ArrayList<Category> categories = dbExchanger.getCategoriesByType(displayType);
dbExchanger.close();
// Setup listView with adapter
adapter = new CategoryListAdapter(getActivity().getApplicationContext(), R.layout.categories_listview_items, categories);
listView.setAdapter(adapter);
listView.setOnItemClickListener(new ListView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
long id) {
Intent editIntent = new Intent(getActivity(), NewCategory.class);
editIntent.putExtra(CATEGORIES_MODE, CATEGORIES_EDIT_MODE);
editIntent.putExtra(CATEGORIES_ID, (int) id);
startActivityForResult(editIntent, 1);
}
});
listView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
@Override
public boolean onItemLongClick(AdapterView<?> adapterView, View view, int i, long id) {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setMessage(getString(R.string.delete_category));
final int longClickedId = (int) id;
builder.setPositiveButton(R.string.delete, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
TransactionDatabaseExchanger databaseExchanger = new TransactionDatabaseExchanger(getActivity());
databaseExchanger.open();
databaseExchanger.deleteCategory(longClickedId);
databaseExchanger.close();
displayList();
}
});
builder.setNegativeButton(R.string.cancel, null);
builder.create().show();
return true;
}
});
}
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 1) {
if(resultCode == NewCategory.RESULT_OK){
displayList();
}
if (resultCode == NewCategory.RESULT_CANCELED) {
}
}
}//onActivityResult
}
|
[
"[email protected]"
] | |
5ae8318c3c86e3eaa28befa5421a814e3dbdde2b
|
4552f488e5a8049ec4085c3fb7e5a315a419bc5c
|
/src/main/java/com/github/edgar615/util/vertx/deployment/MainVerticle.java
|
ce9d70ad041f9e657c959b32bcd6368833430123
|
[
"Apache-2.0"
] |
permissive
|
edgar615/vertx-util
|
f7c127791336a0c2c7bad6f16b55708647d90377
|
39c061c142bf874f424888181f463209419bab01
|
refs/heads/master
| 2021-01-17T15:21:15.080624 | 2018-08-20T08:38:20 | 2018-08-20T08:38:20 | 68,521,348 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 5,435 |
java
|
package com.github.edgar615.util.vertx.deployment;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.AsyncResult;
import io.vertx.core.CompositeFuture;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.eventbus.MessageCodec;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 用于启动Vert.x应用的组件，通过配置文件指定需要启动哪些Verticle，避免硬编码.
* <p>
* <pre>
* "verticles": {
* "MetricsVerticle": {
* "class": "com.groupon.vertx.utils.MetricsVerticle",
* "instances": 1,
* "worker": true,
* "config": { }
* },
* "ExampleVerticle": {
* "class": "com.groupon.example.verticle.ExampleVerticle",
* "instances": 1,
* "worker": true,
* "config": { },
* "dependencies": [ "MetricsVerticle" ]
* }
* }
* </pre>
*
* @author Edgar Date 2017/6/12
*/
public class MainVerticle extends AbstractVerticle {
private static final Logger LOGGER = LoggerFactory.getLogger(MainVerticle.class);
// private final AtomicInteger verticleCount = new AtomicInteger(0);
@Override
public void start(Future<Void> startFuture) throws Exception {
//注册codec, codec的失败并不影响整个应用（可能会导致某些功能失败）
registerMessageCodecs(vertx, config());
//启动
MainVerticleDeployment deployment = new MainVerticleDeployment(config().copy());
//优先启动没有依赖的Verticle
List<Future> futures = new ArrayList<>();
deployment.getDeployments().stream()
.filter(o -> o.getDependencyVerticles().isEmpty())
.forEach(d -> {
Future<Void> future = Future.future();
futures.add(future);
d.deploy(vertx,
createHandler(deployment, d.getVerticleName(), future));
});
if (futures.isEmpty()) {
startFuture.complete();
return;
}
CompositeFuture.all(futures)
.setHandler(ar -> {
if (ar.succeeded()) {
LOGGER.info("MainVerticle deployed succeeded");
startFuture.complete();
} else {
LOGGER.error("MainVerticle deployed failed because {}", ar.cause().getMessage());
startFuture.fail(ar.cause());
}
});
}
/**
* 每次有Verticle启动完成之后都检查一遍待启动的verticle，如果verticle的依赖全部启动完，则开始启动这个verticle
*
* @param deployment
* @param verticle
* @param completeFuture
*/
private void checkAndDeploy(MainVerticleDeployment deployment, String verticle,
Future<Void> completeFuture) {
List<Future> futures = new ArrayList<>();
deployment.getDeployments().forEach(d -> {
boolean checkResult = d.checkPrecondition(verticle);
if (checkResult) {
Future<Void> future = Future.future();
futures.add(future);
d.deploy(vertx, createHandler(deployment, d.getVerticleName(), future));
}
});
if (futures.isEmpty()) {
completeFuture.complete();
return;
}
CompositeFuture.all(futures)
.setHandler(ar -> {
if (ar.succeeded()) {
completeFuture.complete();
} else {
completeFuture.fail(ar.cause());
}
});
// if (verticleCount.get() == deployment.getDeployments().size()) {
// if (!completeFuture.isComplete()) {
// completeFuture.complete();
// }
// }
}
private Handler<AsyncResult<String>> createHandler(MainVerticleDeployment deployment,
String verticle, Future<Void> completeFuture) {
return ar -> {
if (ar.failed()) {
ar.cause().printStackTrace();
completeFuture.fail(ar.cause());
return;
}
// verticleCount.incrementAndGet();
checkAndDeploy(deployment, verticle, completeFuture);
};
}
private void registerMessageCodecs(
final Vertx vertx,
final JsonObject config) {
final JsonArray messageCodecs = config.getJsonArray("messageCodecs", new JsonArray());
for (final Object messageCodecClassNameObject : messageCodecs.getList()) {
if (messageCodecClassNameObject instanceof String) {
final String messageCodecClassName = (String) messageCodecClassNameObject;
try {
final MessageCodec<?, ?> messageCodec
= (MessageCodec<?, ?>) Class.forName(messageCodecClassName).newInstance();
vertx.eventBus().registerCodec(messageCodec);
} catch (final InstantiationException | IllegalAccessException | ClassNotFoundException e) {
LOGGER.warn("Failed to instantiate message codec:{}",
messageCodecClassName, e);
// throw new CodecRegistrationException(
// String.format(
// "Failed to instantiate message codec %s",
// messageCodecClassName),
// e);
}
} else {
LOGGER.warn("Ignoring non-string message codec class name:{}",
messageCodecClassNameObject);
}
}
}
}
|
[
"[email protected]"
] | |
64c74ba48d4c1acc5d41dc8f6b05841afc4dce79
|
612e27e22ea450ab7d2acdeb6d47a66d20c177f4
|
/src/main/java/com/hackerrank/thirtydaysofcode/DataTypes.java
|
2439c124f36e71bfc8e71bfe28bc608f0a48a2e9
|
[] |
no_license
|
mrcosta/anotherlevelcoding
|
bf16eac665554b818be3f91002062095d2057a3c
|
ff09e9776e756532b55cd47cba5af3a0fe7c3d8f
|
refs/heads/master
| 2021-01-20T17:07:38.426515 | 2017-08-28T01:19:25 | 2017-08-28T01:19:25 | 90,864,969 | 0 | 1 | null | 2017-05-14T21:58:48 | 2017-05-10T13:03:05 |
Java
|
UTF-8
|
Java
| false | false | 335 |
java
|
package com.hackerrank.thirtydaysofcode;
public class DataTypes {
public int sumInt(int input) {
return input + 4;
}
public double sumDouble(double doubleInput) {
return doubleInput + 4;
}
public String concatenateStrings(String stringInput) {
return "HackerRank " + stringInput;
}
}
|
[
"[email protected]"
] | |
3c9e8252399c772214c3e3eb8c2b19ad2d094787
|
e108d65747c07078ae7be6dcd6369ac359d098d7
|
/org/opencv/calib3d/Calib3d.java
|
99887ef4e5d2d305cd397a378de521e7bd67a8ec
|
[
"MIT"
] |
permissive
|
kelu124/pyS3
|
50f30b51483bf8f9581427d2a424e239cfce5604
|
86eb139d971921418d6a62af79f2868f9c7704d5
|
refs/heads/master
| 2020-03-13T01:51:42.054846 | 2018-04-24T21:03:03 | 2018-04-24T21:03:03 | 130,913,008 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 30,862 |
java
|
package org.opencv.calib3d;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.MatOfPoint3f;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Size;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
public class Calib3d {
public static final int CALIB_CB_ADAPTIVE_THRESH = 1;
public static final int CALIB_CB_ASYMMETRIC_GRID = 2;
public static final int CALIB_CB_CLUSTERING = 4;
public static final int CALIB_CB_FAST_CHECK = 8;
public static final int CALIB_CB_FILTER_QUADS = 4;
public static final int CALIB_CB_NORMALIZE_IMAGE = 2;
public static final int CALIB_CB_SYMMETRIC_GRID = 1;
public static final int CALIB_FIX_ASPECT_RATIO = 2;
public static final int CALIB_FIX_FOCAL_LENGTH = 16;
public static final int CALIB_FIX_INTRINSIC = 256;
public static final int CALIB_FIX_K1 = 32;
public static final int CALIB_FIX_K2 = 64;
public static final int CALIB_FIX_K3 = 128;
public static final int CALIB_FIX_K4 = 2048;
public static final int CALIB_FIX_K5 = 4096;
public static final int CALIB_FIX_K6 = 8192;
public static final int CALIB_FIX_PRINCIPAL_POINT = 4;
public static final int CALIB_RATIONAL_MODEL = 16384;
public static final int CALIB_SAME_FOCAL_LENGTH = 512;
public static final int CALIB_USE_INTRINSIC_GUESS = 1;
public static final int CALIB_ZERO_DISPARITY = 1024;
public static final int CALIB_ZERO_TANGENT_DIST = 8;
private static final int CV_CALIB_FIX_ASPECT_RATIO = 2;
private static final int CV_CALIB_FIX_FOCAL_LENGTH = 16;
private static final int CV_CALIB_FIX_INTRINSIC = 256;
private static final int CV_CALIB_FIX_K1 = 32;
private static final int CV_CALIB_FIX_K2 = 64;
private static final int CV_CALIB_FIX_K3 = 128;
private static final int CV_CALIB_FIX_K4 = 2048;
private static final int CV_CALIB_FIX_K5 = 4096;
private static final int CV_CALIB_FIX_K6 = 8192;
private static final int CV_CALIB_FIX_PRINCIPAL_POINT = 4;
private static final int CV_CALIB_RATIONAL_MODEL = 16384;
private static final int CV_CALIB_SAME_FOCAL_LENGTH = 512;
private static final int CV_CALIB_USE_INTRINSIC_GUESS = 1;
private static final int CV_CALIB_ZERO_DISPARITY = 1024;
private static final int CV_CALIB_ZERO_TANGENT_DIST = 8;
public static final int CV_EPNP = 1;
private static final int CV_FM_7POINT = 1;
private static final int CV_FM_8POINT = 2;
private static final int CV_FM_LMEDS = 4;
private static final int CV_FM_RANSAC = 8;
public static final int CV_ITERATIVE = 0;
private static final int CV_LMEDS = 4;
public static final int CV_P3P = 2;
private static final int CV_RANSAC = 8;
public static final int EPNP = 1;
public static final int FM_7POINT = 1;
public static final int FM_8POINT = 2;
public static final int FM_LMEDS = 4;
public static final int FM_RANSAC = 8;
public static final int ITERATIVE = 0;
public static final int LMEDS = 4;
public static final int P3P = 2;
public static final int RANSAC = 8;
private static native double[] RQDecomp3x3_0(long j, long j2, long j3, long j4, long j5, long j6);
private static native double[] RQDecomp3x3_1(long j, long j2, long j3);
private static native void Rodrigues_0(long j, long j2, long j3);
private static native void Rodrigues_1(long j, long j2);
private static native double calibrateCamera_0(long j, long j2, double d, double d2, long j3, long j4, long j5, long j6, int i, int i2, int i3, double d3);
private static native double calibrateCamera_1(long j, long j2, double d, double d2, long j3, long j4, long j5, long j6, int i);
private static native double calibrateCamera_2(long j, long j2, double d, double d2, long j3, long j4, long j5, long j6);
private static native void calibrationMatrixValues_0(long j, double d, double d2, double d3, double d4, double[] dArr, double[] dArr2, double[] dArr3, double[] dArr4, double[] dArr5);
private static native void composeRT_0(long j, long j2, long j3, long j4, long j5, long j6, long j7, long j8, long j9, long j10, long j11, long j12, long j13, long j14);
private static native void composeRT_1(long j, long j2, long j3, long j4, long j5, long j6);
private static native void computeCorrespondEpilines_0(long j, int i, long j2, long j3);
private static native void convertPointsFromHomogeneous_0(long j, long j2);
private static native void convertPointsToHomogeneous_0(long j, long j2);
private static native void correctMatches_0(long j, long j2, long j3, long j4, long j5);
private static native void decomposeProjectionMatrix_0(long j, long j2, long j3, long j4, long j5, long j6, long j7, long j8);
private static native void decomposeProjectionMatrix_1(long j, long j2, long j3, long j4);
private static native void drawChessboardCorners_0(long j, double d, double d2, long j2, boolean z);
private static native int estimateAffine3D_0(long j, long j2, long j3, long j4, double d, double d2);
private static native int estimateAffine3D_1(long j, long j2, long j3, long j4);
private static native void filterSpeckles_0(long j, double d, int i, double d2, long j2);
private static native void filterSpeckles_1(long j, double d, int i, double d2);
private static native boolean findChessboardCorners_0(long j, double d, double d2, long j2, int i);
private static native boolean findChessboardCorners_1(long j, double d, double d2, long j2);
private static native boolean findCirclesGridDefault_0(long j, double d, double d2, long j2, int i);
private static native boolean findCirclesGridDefault_1(long j, double d, double d2, long j2);
private static native long findFundamentalMat_0(long j, long j2, int i, double d, double d2, long j3);
private static native long findFundamentalMat_1(long j, long j2, int i, double d, double d2);
private static native long findFundamentalMat_2(long j, long j2);
private static native long findHomography_0(long j, long j2, int i, double d, long j3);
private static native long findHomography_1(long j, long j2, int i, double d);
private static native long findHomography_2(long j, long j2);
private static native long getOptimalNewCameraMatrix_0(long j, long j2, double d, double d2, double d3, double d4, double d5, double[] dArr, boolean z);
private static native long getOptimalNewCameraMatrix_1(long j, long j2, double d, double d2, double d3);
private static native double[] getValidDisparityROI_0(int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10, int i11);
private static native long initCameraMatrix2D_0(long j, long j2, double d, double d2, double d3);
private static native long initCameraMatrix2D_1(long j, long j2, double d, double d2);
private static native void matMulDeriv_0(long j, long j2, long j3, long j4);
private static native void projectPoints_0(long j, long j2, long j3, long j4, long j5, long j6, long j7, double d);
private static native void projectPoints_1(long j, long j2, long j3, long j4, long j5, long j6);
private static native float rectify3Collinear_0(long j, long j2, long j3, long j4, long j5, long j6, long j7, long j8, double d, double d2, long j9, long j10, long j11, long j12, long j13, long j14, long j15, long j16, long j17, long j18, long j19, double d3, double d4, double d5, double[] dArr, double[] dArr2, int i);
private static native void reprojectImageTo3D_0(long j, long j2, long j3, boolean z, int i);
private static native void reprojectImageTo3D_1(long j, long j2, long j3, boolean z);
private static native void reprojectImageTo3D_2(long j, long j2, long j3);
private static native void solvePnPRansac_0(long j, long j2, long j3, long j4, long j5, long j6, boolean z, int i, float f, int i2, long j7, int i3);
private static native void solvePnPRansac_1(long j, long j2, long j3, long j4, long j5, long j6);
private static native boolean solvePnP_0(long j, long j2, long j3, long j4, long j5, long j6, boolean z, int i);
private static native boolean solvePnP_1(long j, long j2, long j3, long j4, long j5, long j6);
private static native double stereoCalibrate_0(long j, long j2, long j3, long j4, long j5, long j6, long j7, double d, double d2, long j8, long j9, long j10, long j11, int i, int i2, double d3, int i3);
private static native double stereoCalibrate_1(long j, long j2, long j3, long j4, long j5, long j6, long j7, double d, double d2, long j8, long j9, long j10, long j11);
private static native boolean stereoRectifyUncalibrated_0(long j, long j2, long j3, double d, double d2, long j4, long j5, double d3);
private static native boolean stereoRectifyUncalibrated_1(long j, long j2, long j3, double d, double d2, long j4, long j5);
private static native void stereoRectify_0(long j, long j2, long j3, long j4, double d, double d2, long j5, long j6, long j7, long j8, long j9, long j10, long j11, int i, double d3, double d4, double d5, double[] dArr, double[] dArr2);
private static native void stereoRectify_1(long j, long j2, long j3, long j4, double d, double d2, long j5, long j6, long j7, long j8, long j9, long j10, long j11);
private static native void triangulatePoints_0(long j, long j2, long j3, long j4, long j5);
private static native void validateDisparity_0(long j, long j2, int i, int i2, int i3);
private static native void validateDisparity_1(long j, long j2, int i, int i2);
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz) {
return RQDecomp3x3_0(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj, Qx.nativeObj, Qy.nativeObj, Qz.nativeObj);
}
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ) {
return RQDecomp3x3_1(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj);
}
public static void Rodrigues(Mat src, Mat dst, Mat jacobian) {
Rodrigues_0(src.nativeObj, dst.nativeObj, jacobian.nativeObj);
}
public static void Rodrigues(Mat src, Mat dst) {
Rodrigues_1(src.nativeObj, dst.nativeObj);
}
public static double calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, int flags, TermCriteria criteria) {
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
return retVal;
}
public static double calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs, int flags) {
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
return retVal;
}
public static double calibrateCamera(List<Mat> objectPoints, List<Mat> imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List<Mat> rvecs, List<Mat> tvecs) {
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
return retVal;
}
public static void calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio) {
double[] fovx_out = new double[1];
double[] fovy_out = new double[1];
double[] focalLength_out = new double[1];
double[] principalPoint_out = new double[2];
double[] aspectRatio_out = new double[1];
calibrationMatrixValues_0(cameraMatrix.nativeObj, imageSize.width, imageSize.height, apertureWidth, apertureHeight, fovx_out, fovy_out, focalLength_out, principalPoint_out, aspectRatio_out);
if (fovx != null) {
fovx[0] = fovx_out[0];
}
if (fovy != null) {
fovy[0] = fovy_out[0];
}
if (focalLength != null) {
focalLength[0] = focalLength_out[0];
}
if (principalPoint != null) {
principalPoint.f203x = principalPoint_out[0];
principalPoint.f204y = principalPoint_out[1];
}
if (aspectRatio != null) {
aspectRatio[0] = aspectRatio_out[0];
}
}
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2) {
composeRT_0(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj, dt3dt1.nativeObj, dt3dr2.nativeObj, dt3dt2.nativeObj);
}
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3) {
composeRT_1(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj);
}
public static void computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines) {
computeCorrespondEpilines_0(points.nativeObj, whichImage, F.nativeObj, lines.nativeObj);
}
public static void convertPointsFromHomogeneous(Mat src, Mat dst) {
convertPointsFromHomogeneous_0(src.nativeObj, dst.nativeObj);
}
public static void convertPointsToHomogeneous(Mat src, Mat dst) {
convertPointsToHomogeneous_0(src.nativeObj, dst.nativeObj);
}
public static void correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2) {
correctMatches_0(F.nativeObj, points1.nativeObj, points2.nativeObj, newPoints1.nativeObj, newPoints2.nativeObj);
}
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles) {
decomposeProjectionMatrix_0(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj, rotMatrixY.nativeObj, rotMatrixZ.nativeObj, eulerAngles.nativeObj);
}
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect) {
decomposeProjectionMatrix_1(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj);
}
public static void drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound) {
drawChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners.nativeObj, patternWasFound);
}
public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence) {
return estimateAffine3D_0(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj, ransacThreshold, confidence);
}
public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers) {
return estimateAffine3D_1(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj);
}
public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf) {
filterSpeckles_0(img.nativeObj, newVal, maxSpeckleSize, maxDiff, buf.nativeObj);
}
public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff) {
filterSpeckles_1(img.nativeObj, newVal, maxSpeckleSize, maxDiff);
}
public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags) {
return findChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners.nativeObj, flags);
}
public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners) {
return findChessboardCorners_1(image.nativeObj, patternSize.width, patternSize.height, corners.nativeObj);
}
public static boolean findCirclesGridDefault(Mat image, Size patternSize, Mat centers, int flags) {
return findCirclesGridDefault_0(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj, flags);
}
public static boolean findCirclesGridDefault(Mat image, Size patternSize, Mat centers) {
return findCirclesGridDefault_1(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj);
}
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double param1, double param2, Mat mask) {
return new Mat(findFundamentalMat_0(points1.nativeObj, points2.nativeObj, method, param1, param2, mask.nativeObj));
}
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double param1, double param2) {
return new Mat(findFundamentalMat_1(points1.nativeObj, points2.nativeObj, method, param1, param2));
}
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2) {
return new Mat(findFundamentalMat_2(points1.nativeObj, points2.nativeObj));
}
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask) {
return new Mat(findHomography_0(srcPoints.nativeObj, dstPoints.nativeObj, method, ransacReprojThreshold, mask.nativeObj));
}
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold) {
return new Mat(findHomography_1(srcPoints.nativeObj, dstPoints.nativeObj, method, ransacReprojThreshold));
}
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints) {
return new Mat(findHomography_2(srcPoints.nativeObj, dstPoints.nativeObj));
}
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint) {
double[] validPixROI_out = new double[4];
Mat mat = new Mat(getOptimalNewCameraMatrix_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha, newImgSize.width, newImgSize.height, validPixROI_out, centerPrincipalPoint));
if (validPixROI != null) {
validPixROI.f205x = (int) validPixROI_out[0];
validPixROI.f206y = (int) validPixROI_out[1];
validPixROI.width = (int) validPixROI_out[2];
validPixROI.height = (int) validPixROI_out[3];
}
return mat;
}
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha) {
return new Mat(getOptimalNewCameraMatrix_1(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha));
}
public static Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) {
return new Rect(getValidDisparityROI_0(roi1.f205x, roi1.f206y, roi1.width, roi1.height, roi2.f205x, roi2.f206y, roi2.width, roi2.height, minDisparity, numberOfDisparities, SADWindowSize));
}
public static Mat initCameraMatrix2D(List<MatOfPoint3f> objectPoints, List<MatOfPoint2f> imagePoints, Size imageSize, double aspectRatio) {
return new Mat(initCameraMatrix2D_0(Converters.vector_vector_Point3f_to_Mat(objectPoints, new ArrayList(objectPoints != null ? objectPoints.size() : 0)).nativeObj, Converters.vector_vector_Point2f_to_Mat(imagePoints, new ArrayList(imagePoints != null ? imagePoints.size() : 0)).nativeObj, imageSize.width, imageSize.height, aspectRatio));
}
public static Mat initCameraMatrix2D(List<MatOfPoint3f> objectPoints, List<MatOfPoint2f> imagePoints, Size imageSize) {
int size;
int i = 0;
if (objectPoints != null) {
size = objectPoints.size();
} else {
size = 0;
}
Mat objectPoints_mat = Converters.vector_vector_Point3f_to_Mat(objectPoints, new ArrayList(size));
if (imagePoints != null) {
i = imagePoints.size();
}
return new Mat(initCameraMatrix2D_1(objectPoints_mat.nativeObj, Converters.vector_vector_Point2f_to_Mat(imagePoints, new ArrayList(i)).nativeObj, imageSize.width, imageSize.height));
}
public static void matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB) {
matMulDeriv_0(A.nativeObj, B.nativeObj, dABdA.nativeObj, dABdB.nativeObj);
}
public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio) {
projectPoints_0(objectPoints.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, imagePoints.nativeObj, jacobian.nativeObj, aspectRatio);
}
public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints) {
projectPoints_1(objectPoints.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, imagePoints.nativeObj);
}
public static float rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, List<Mat> imgpt1, List<Mat> imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags) {
double[] roi1_out = new double[4];
double[] roi2_out = new double[4];
double d = alpha;
float retVal = rectify3Collinear_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, cameraMatrix3.nativeObj, distCoeffs3.nativeObj, Converters.vector_Mat_to_Mat(imgpt1).nativeObj, Converters.vector_Mat_to_Mat(imgpt3).nativeObj, imageSize.width, imageSize.height, R12.nativeObj, T12.nativeObj, R13.nativeObj, T13.nativeObj, R1.nativeObj, R2.nativeObj, R3.nativeObj, P1.nativeObj, P2.nativeObj, P3.nativeObj, Q.nativeObj, d, newImgSize.width, newImgSize.height, roi1_out, roi2_out, flags);
if (roi1 != null) {
roi1.f205x = (int) roi1_out[0];
roi1.f206y = (int) roi1_out[1];
roi1.width = (int) roi1_out[2];
roi1.height = (int) roi1_out[3];
}
if (roi2 != null) {
roi2.f205x = (int) roi2_out[0];
roi2.f206y = (int) roi2_out[1];
roi2.width = (int) roi2_out[2];
roi2.height = (int) roi2_out[3];
}
return retVal;
}
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth) {
reprojectImageTo3D_0(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues, ddepth);
}
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues) {
reprojectImageTo3D_1(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues);
}
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q) {
reprojectImageTo3D_2(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj);
}
public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags) {
return solvePnP_0(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, flags);
}
public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec) {
return solvePnP_1(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj);
}
public static void solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, int minInliersCount, Mat inliers, int flags) {
boolean z = useExtrinsicGuess;
int i = iterationsCount;
float f = reprojectionError;
int i2 = minInliersCount;
solvePnPRansac_0(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj, z, i, f, i2, inliers.nativeObj, flags);
}
public static void solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec) {
solvePnPRansac_1(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj);
}
public static double stereoCalibrate(List<Mat> objectPoints, List<Mat> imagePoints1, List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, TermCriteria criteria, int flags) {
return stereoCalibrate_0(Converters.vector_Mat_to_Mat(objectPoints).nativeObj, Converters.vector_Mat_to_Mat(imagePoints1).nativeObj, Converters.vector_Mat_to_Mat(imagePoints2).nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, flags);
}
public static double stereoCalibrate(List<Mat> objectPoints, List<Mat> imagePoints1, List<Mat> imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F) {
return stereoCalibrate_1(Converters.vector_Mat_to_Mat(objectPoints).nativeObj, Converters.vector_Mat_to_Mat(imagePoints1).nativeObj, Converters.vector_Mat_to_Mat(imagePoints2).nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj);
}
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1, Rect validPixROI2) {
double[] validPixROI1_out = new double[4];
double[] validPixROI2_out = new double[4];
stereoRectify_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha, newImageSize.width, newImageSize.height, validPixROI1_out, validPixROI2_out);
if (validPixROI1 != null) {
validPixROI1.f205x = (int) validPixROI1_out[0];
validPixROI1.f206y = (int) validPixROI1_out[1];
validPixROI1.width = (int) validPixROI1_out[2];
validPixROI1.height = (int) validPixROI1_out[3];
}
if (validPixROI2 != null) {
validPixROI2.f205x = (int) validPixROI2_out[0];
validPixROI2.f206y = (int) validPixROI2_out[1];
validPixROI2.width = (int) validPixROI2_out[2];
validPixROI2.height = (int) validPixROI2_out[3];
}
}
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q) {
stereoRectify_1(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj);
}
public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold) {
return stereoRectifyUncalibrated_0(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj, threshold);
}
public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2) {
return stereoRectifyUncalibrated_1(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj);
}
public static void triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D) {
triangulatePoints_0(projMatr1.nativeObj, projMatr2.nativeObj, projPoints1.nativeObj, projPoints2.nativeObj, points4D.nativeObj);
}
public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp) {
validateDisparity_0(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities, disp12MaxDisp);
}
public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities) {
validateDisparity_1(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities);
}
}
|
[
"[email protected]"
] | |
22c0c470a4bb9e606c5a58d63148350f8f4519ae
|
7018daa42334cc9e88c52d96aaf3cbf96d1f2adb
|
/src/main/java/io/moonman/emergingtechnology/machines/MachineBase.java
|
02ab17f93a26cb0f5a26602c0407c52f71672cea
|
[
"MIT"
] |
permissive
|
kane-thornwyrd/EmergingTechnology
|
371d8301e8affa4ea67514cc3cb0ff80f45bab7c
|
2148fdc8922296051e9b0b956dae2b8c9eb3cefb
|
refs/heads/master
| 2020-12-01T18:06:20.153288 | 2019-12-29T09:14:58 | 2019-12-29T09:14:58 | 230,721,385 | 0 | 0 |
MIT
| 2019-12-29T08:05:32 | 2019-12-29T08:05:32 | null |
UTF-8
|
Java
| false | false | 1,622 |
java
|
package io.moonman.emergingtechnology.machines;
import io.moonman.emergingtechnology.EmergingTechnology;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.IItemHandler;
public class MachineBase extends Block {
public MachineBase(Material material, String name) {
super(material);
this.setHardness(1.0f);
this.setRegistryName(EmergingTechnology.MODID, name);
this.setUnlocalizedName(EmergingTechnology.MODID + "." + name);
this.setCreativeTab(EmergingTechnology.TECHNOLOGYTAB);
}
@Override
public boolean isOpaqueCube(IBlockState iBlockState) {
return false;
}
@Override
public boolean isFullCube(IBlockState iBlockState) {
return false;
}
@Override
public void breakBlock(World world, BlockPos pos, IBlockState state) {
TileEntity te = world.getTileEntity(pos);
IItemHandler cap = te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
for (int i = 0; i < cap.getSlots(); ++i) {
ItemStack itemstack = cap.getStackInSlot(i);
if (!itemstack.isEmpty()) {
InventoryHelper.spawnItemStack(world, pos.getX(), pos.getY(), pos.getZ(), itemstack);
}
}
}
}
|
[
"[email protected]"
] | |
d27c4ec37ee11eeb96f5ed186d77836aef7523b2
|
b4b6b435418dd14fb66401dbd8bff44c6091bd54
|
/app/src/main/java/com/dupreeincabolnuevo/dupree/mh_fragments_menu/PedidosDigitadosFragment.java
|
f1f6b5de8f796bc5c3ecb79bf93b864ee1f0be17
|
[
"Apache-2.0"
] |
permissive
|
dupreemovil/AzzortiBolivia
|
8768c352ae7ab930c084f3581fc74d7b90efa75b
|
96aad061096ec7c84b2967744df2b09e310c5509
|
refs/heads/master
| 2022-12-03T08:47:44.398314 | 2020-08-02T13:04:48 | 2020-08-02T13:04:48 | 278,187,892 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 6,771 |
java
|
package com.dupreeincabolnuevo.dupree.mh_fragments_menu;
import android.content.Context;
import android.databinding.ViewDataBinding;
import android.support.v4.app.Fragment;
import android.support.v7.widget.GridLayoutManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.View;
import com.dupreeincabolnuevo.dupree.R;
import com.dupreeincabolnuevo.dupree.databinding.FragmentPedidoDigitadoBinding;
import com.dupreeincabolnuevo.dupree.mh_adapters.PedidosDigitadosListAdapter;
import com.dupreeincabolnuevo.dupree.mh_holders.PedidosDigitadosHolder;
import com.dupreeincabolnuevo.dupree.view.fragment.BaseFragment;
import com.dupreeinca.lib_api_rest.controller.ReportesController;
import com.dupreeinca.lib_api_rest.model.base.TTError;
import com.dupreeinca.lib_api_rest.model.base.TTResultListener;
import com.dupreeinca.lib_api_rest.model.dto.request.Identy;
import com.dupreeinca.lib_api_rest.model.dto.response.PedidoDigitado;
import com.dupreeinca.lib_api_rest.model.dto.response.PedidoDigitadoDTO;
import com.dupreeinca.lib_api_rest.model.view.Profile;
import java.util.ArrayList;
import java.util.List;
public class PedidosDigitadosFragment extends BaseFragment implements PedidosDigitadosHolder.Events{
private final String TAG = PedidosDigitadosFragment.class.getName();
private FragmentPedidoDigitadoBinding binding;
private ReportesController reportesController;
private List<PedidoDigitado> list, listFilter;
private PedidosDigitadosListAdapter adapter_pedido_digitado;
public PedidosDigitadosFragment() {
// Required empty public constructor
}
private Profile perfil;
public void loadData(Profile perfil){
this.perfil=perfil;
}
@Override
protected int getMainLayout() {
return R.layout.fragment_pedido_digitado;
}
@Override
protected void initViews(ViewDataBinding view) {
binding = (FragmentPedidoDigitadoBinding) view;
binding.cardViewBackGround.setVisibility(View.INVISIBLE);
binding.tvNombreAsesora.setText("");
binding.recycler.setLayoutManager(new GridLayoutManager(getActivity(),1));
binding.recycler.setHasFixedSize(true);
list = new ArrayList<>();
listFilter = new ArrayList<>();
//incentivoRefs = getResult();
listFilter.addAll(list);
adapter_pedido_digitado = new PedidosDigitadosListAdapter(list, listFilter, this);
binding.recycler.setAdapter(adapter_pedido_digitado);
}
@Override
protected void onLoadedView() {
reportesController = new ReportesController(getContext());
checkPedidosDigitados();
}
public void checkPedidosDigitados(){
if(list.size()<1){//OJO REFREZCAR CON PULL REFRESH
showProgress();
String s=perfil.getValor();
reportesController.getPedidosDigitados(new Identy( ""), new TTResultListener<PedidoDigitadoDTO>() {
@Override
public void success(PedidoDigitadoDTO result) {
dismissProgress();
addPedidosDigitados(result);
updateView(result);
}
@Override
public void error(TTError error) {
dismissProgress();
checkSession(error);
}
});
}
}
private void addPedidosDigitados(PedidoDigitadoDTO pedidosDigitados){
list.clear();
listFilter.clear();
if(pedidosDigitados!=null) {
list.addAll(pedidosDigitados.getResult());
listFilter.addAll(pedidosDigitados.getResult());
adapter_pedido_digitado.notifyDataSetChanged();
}
}
private void updateView(PedidoDigitadoDTO listaACargar){
list.clear();
listFilter.clear();
list.addAll(listaACargar.getResult());
listFilter.addAll(listaACargar.getResult());
binding.cardViewBackGround.setVisibility(View.VISIBLE);
binding.tvNombreAsesora.setText(listaACargar.getStatus());
adapter_pedido_digitado.notifyDataSetChanged();
}
public void searchNewIdenty(String cedula){
showProgress();
reportesController.getPedidosDigitados(new Identy(cedula), new TTResultListener<PedidoDigitadoDTO>() {
@Override
public void success(PedidoDigitadoDTO result) {
dismissProgress();
updateView(result);
}
@Override
public void error(TTError error) {
dismissProgress();
checkSession(error);
}
});
}
@Override
public void onClickRoot(PedidoDigitado dataRow, int row) {
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
// inflater.inflate(R.menu.menu_search, menu);
// final MenuItem searchItem = menu.findItem(R.id.action_search);
// SearchView searchView = (SearchView) searchItem.getActionView();
// searchView.setQueryHint(getString(R.string.cedula_asesora));
//
// EditText txtSearch = searchView.findViewById(android.support.v7.appcompat.R.id.search_src_text);
// txtSearch.setInputType(InputType.TYPE_CLASS_NUMBER);
//
// searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
// @Override
// public boolean onQueryTextSubmit(String query) {
// Log.e(TAG, "onCreateOptionsMenu() -> onQueryTextSubmit() -> " + query);
// searchMyQuery(query);
// searchView.clearFocus();
// return false;//habilita el serach del teclado
// }
//
// @Override
// public boolean onQueryTextChange(String newText) {
// Log.e(TAG, "onCreateOptionsMenu() -> onQueryTextChange() -> " + newText);
// searchViewTextChange(newText);
// return false;
// }
// });
//
// searchView.setIconified(true);//inicialmente oculto
// super.onCreateOptionsMenu(menu, inflater);
}
private void searchMyQuery(String query){
searchNewIdenty(query);
}
public void searchViewTextChange(String newText) {
}
@Override
public void onAttachFragment(Fragment childFragment) {
super.onAttachFragment(childFragment);
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
Log.e(TAG, "onAttach()");
setHasOptionsMenu(true);
}
@Override
public void onDetach() {
super.onDetach();
Log.e(TAG, "onDetach()");
setHasOptionsMenu(false);
}
}
|
[
"[email protected]"
] | |
8e64305e4d9b5981db93ff413d8a365eaea6e10c
|
9a6ea6087367965359d644665b8d244982d1b8b6
|
/src/main/java/X/AnonymousClass2P0.java
|
900ec7c0e6cb50d8db6ab5d4385b2dac808d5918
|
[] |
no_license
|
technocode/com.wa_2.21.2
|
a3dd842758ff54f207f1640531374d3da132b1d2
|
3c4b6f3c7bdef7c1523c06d5bd9a90b83acc80f9
|
refs/heads/master
| 2023-02-12T11:20:28.666116 | 2021-01-14T10:22:21 | 2021-01-14T10:22:21 | 329,578,591 | 2 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,811 |
java
|
package X;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import com.whatsapp.gallerypicker.GalleryPickerFragment;
import com.whatsapp.util.Log;
/* renamed from: X.2P0 reason: invalid class name */
public class AnonymousClass2P0 extends BroadcastReceiver {
public final /* synthetic */ GalleryPickerFragment A00;
public AnonymousClass2P0(GalleryPickerFragment galleryPickerFragment) {
this.A00 = galleryPickerFragment;
}
public void onReceive(Context context, Intent intent) {
GalleryPickerFragment galleryPickerFragment = this.A00;
if (galleryPickerFragment != null) {
String action = intent.getAction();
if (action != null) {
switch (action.hashCode()) {
case -1514214344:
if (action.equals("android.intent.action.MEDIA_MOUNTED")) {
Log.i("gallerypicker/receivemediabroadcast/ACTION_MEDIA_MOUNTED");
return;
}
return;
case -1142424621:
if (action.equals("android.intent.action.MEDIA_SCANNER_FINISHED")) {
Log.i("gallerypicker/receivemediabroadcast/ACTION_MEDIA_SCANNER_FINISHED");
galleryPickerFragment.A0p(false, false);
return;
}
return;
case -963871873:
if (action.equals("android.intent.action.MEDIA_UNMOUNTED")) {
Log.i("gallerypicker/receivemediabroadcast/ACTION_MEDIA_UNMOUNTED");
galleryPickerFragment.A0p(true, false);
return;
}
return;
case -625887599:
if (action.equals("android.intent.action.MEDIA_EJECT")) {
Log.i("gallerypicker/receivemediabroadcast/ACTION_MEDIA_EJECT");
galleryPickerFragment.A0p(true, false);
return;
}
return;
case 1412829408:
if (action.equals("android.intent.action.MEDIA_SCANNER_STARTED")) {
Log.i("gallerypicker/receivemediabroadcast/ACTION_MEDIA_SCANNER_STARTED");
galleryPickerFragment.A0p(false, true);
return;
}
return;
default:
return;
}
}
} else {
throw null;
}
}
}
|
[
"[email protected]"
] | |
e3b77de06d0a01daa375a9b20d272bf0c9a60472
|
b7a3683d3148fd113304cd501295ce8135283ea3
|
/src/a/entity/gus/b/swing1/textcomp/cust/autoedit1/EntityImpl.java
|
db17b392c81bcc7383a551c5c36b33bfc15d07e2
|
[] |
no_license
|
gusjava/a
|
b589909551dabc34d63a96556b4ddd38569f911a
|
9745657dd2d54e65a3c0d0dd8109fb19e0461a5b
|
refs/heads/main
| 2023-09-01T12:35:56.770805 | 2021-10-07T06:51:57 | 2021-10-07T06:51:57 | 393,880,076 | 1 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,679 |
java
|
package a.entity.gus.b.swing1.textcomp.cust.autoedit1;
import a.framework.*;
import javax.swing.text.JTextComponent;
import javax.swing.JComponent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class EntityImpl implements Entity, P {
public String creationDate() {return "20210926";}
private Service performEnter;
private Service performTab;
private Service performTabInv;
public EntityImpl() throws Exception
{
performEnter = Outside.service(this,"gus.b.swing1.textcomp.cust.autoedit1.enter.perform");
performTab = Outside.service(this,"gus.b.swing1.textcomp.cust.autoedit1.tab.perform");
performTabInv = Outside.service(this,"gus.b.swing1.textcomp.cust.autoedit1.tab_inv.perform");
}
public void p(Object obj) throws Exception
{new Holder1((JTextComponent) obj);}
private class Holder1 implements KeyListener
{
private JTextComponent comp;
public Holder1(JTextComponent comp)
{
this.comp = comp;
comp.addKeyListener(this);
}
public void keyTyped(KeyEvent e) {}
public void keyReleased(KeyEvent e) {}
public void keyPressed(KeyEvent e)
{
int code = e.getKeyCode();
if(isShift(e))
{
switch(code)
{
case KeyEvent.VK_TAB: perform(performTabInv,comp);break;
}
}
else
{
switch(code)
{
case KeyEvent.VK_ENTER: perform(performEnter,comp);break;
case KeyEvent.VK_TAB: perform(performTab,comp);break;
}
}
}
}
private void perform(P p, JComponent comp)
{
try{p.p(comp);}
catch(Exception e)
{Outside.err(this,"perform(P,JTextComponent)",e);}
}
private boolean isShift(KeyEvent e)
{return e.getModifiers() == KeyEvent.SHIFT_MASK;}
}
|
[
"[email protected]"
] | |
b617f6312b3ef6ee22c1f5aa13e0dbfa3a437fae
|
11968abfbfe936770c0e811f525bdff36f77d397
|
/x.SelfTasks/src/examplesCheck/E002_enum.java
|
ff549550c400f0126f9f5488c5cb184daf479036
|
[] |
no_license
|
sunsey/JavaRush
|
92f2e2bdc9029a694ba3ed957dc3dd377a67b05e
|
247fb80d0d82e6a3b585f7abac7cdee5317c44c1
|
refs/heads/master
| 2020-12-13T19:24:45.684580 | 2017-09-02T14:47:09 | 2017-09-02T14:47:09 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 868 |
java
|
package examplesCheck;
public class E002_enum {
public static void main(String args[]) {
User user = new User();
user.setCounter(TestEnum.ONE);
System.out.println(user.getCounter());
for (TestEnum te : TestEnum.values()) {
System.out.println(te.value);
}
}
public static enum TestEnum {
ONE("1"),
TWO("2"),
THREEE("3");
private String value;
private TestEnum(String value) {
this.value = value;
}
public String getDisplayedName() {
return this.value;
}
}
public static class User {
private TestEnum counter;
public TestEnum getCounter() {
return counter;
}
public void setCounter(TestEnum counter) {
this.counter = counter;
}
}
}
|
[
"[email protected]"
] | |
1634656afcdfadfa3e592bb279f7a960f983fe77
|
af71555e266b2173aa5da91734d46122bf986897
|
/robobinding/src/main/java/org/robobinding/viewattribute/grouped/GroupedViewAttribute.java
|
9493c1368ddd77bd8e7864f658ba42ae91584235
|
[
"Apache-2.0"
] |
permissive
|
403462630/RoboBinding
|
de73581252540b76ec570245710c174aad8718b1
|
bfedc1ea56bbcc53833eb82e2b6b2a66e520bce4
|
refs/heads/master
| 2021-01-25T00:29:41.574975 | 2014-08-03T13:16:16 | 2014-08-03T13:16:16 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 290 |
java
|
package org.robobinding.viewattribute.grouped;
import android.view.View;
/**
*
* @since 1.0
* @version $Revision: 1.0 $
* @author Cheng Wei
*/
public interface GroupedViewAttribute<T extends View> extends ChildAttributesResolver, InitializedGroupedViewAttribute<T> {
}
|
[
"[email protected]"
] | |
728af736294a219f5fc926b9f51ccb693d273932
|
18e28bc3a6c08c13807a1f65d0c94d66961b389d
|
/servlet/src/packa/ParameterServlet.java
|
6062f9eef430c0406ea10f1602469b11c8b918b3
|
[] |
no_license
|
CR-deligt/LearnJavaWeb
|
afeccbbcf38838a01f8a5de9d450243d7dbdb140
|
a82613902655cefcd3cc49165093a8f0f22e8375
|
refs/heads/main
| 2023-08-14T10:58:47.022334 | 2021-10-10T03:51:07 | 2021-10-10T03:51:07 | 407,595,170 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,879 |
java
|
package packa;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
public class ParameterServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("-------------doGet------------");
// 获取请求参数
String username = req.getParameter("username");
//1 先以iso8859-1进行编码
//2 再以utf-8进行解码
username = new String(username.getBytes("iso-8859-1"), "UTF-8");
String password = req.getParameter("password");
String[] hobby = req.getParameterValues("hobby");//多个值使用getParameterValues
System.out.println("用户名：" + username);
System.out.println("密码：" + password);
System.out.println("兴趣爱好：" + Arrays.asList(hobby));
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求体的字符集为UTF-8，从而解决post请求的中文乱码问题
// 也要在获取请求参数之前调用才有效
req.setCharacterEncoding("UTF-8");
System.out.println("-------------doPost------------");
// 获取请求参数
String username = req.getParameter("username");
String password = req.getParameter("password");
String[] hobby = req.getParameterValues("hobby");
System.out.println("用户名：" + username);
System.out.println("密码：" + password);
System.out.println("兴趣爱好：" + Arrays.asList(hobby));
}
}
|
[
"[email protected]"
] | |
bc2313c778acaccab0e4cec2096fa30ffa3432d2
|
fb01cb0533ac199113705c6c843dd4b80d03a345
|
/test/src/main/java/spring/TestApplication.java
|
28280dc24f0baed20cbc13960b7c62fdf2d8b1e7
|
[] |
no_license
|
Sehun-Kim/spring-bean-lifecycle
|
ab1e3ac8beb7a0bb05148c5349364d187584e554
|
0f06d4772da823a4d6a5317ea456baae18d12a1f
|
refs/heads/master
| 2020-04-08T23:39:42.148683 | 2018-12-02T14:58:19 | 2018-12-02T14:58:19 | 159,834,471 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 345 |
java
|
package spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
// Spring-Boot 실행 시 진입 클래스
@SpringBootApplication
public class TestApplication {
public static void main(String arg[]){
SpringApplication.run(TestApplication.class, arg);
}
}
|
[
"[email protected]"
] | |
e51eec330ab39ee831e9016ac9f18dac278b48e0
|
0f998b982477b5e8c56d4560e7db368673af966b
|
/src/main/RawPcmStream.java
|
3791d48976b04e9ea0a87ee7a768707ba0a2889d
|
[] |
no_license
|
hlwgroups/RuneScape-MIDI-Player-Suite
|
2cc49ee30f1b8fc22b541f0403996aa51d4d9f59
|
6612a77458ab69f4212a38f8fcbdd701b458ad6c
|
refs/heads/master
| 2022-04-12T08:51:27.541628 | 2020-02-09T20:07:41 | 2020-02-09T20:07:41 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 49,869 |
java
|
package main;
public class RawPcmStream extends PcmStream {
int attackEnvelopeFactor;
int notePitchFactor;
int noteVelocityFactor;
int __o;
int __u;
int rightChannelPan;
int leftChannelPan;
int loopValue;
int start;
int end;
boolean enableEffects;
int surfaceOffsetY;
int __i;
int __a;
int __z;
RawPcmStream(AudioBuffer var1, int var2, int var3, int var4) {
super.sound = var1;
this.start = var1.start;
this.end = var1.end;
this.enableEffects = var1.bool;
this.notePitchFactor = var2;
this.noteVelocityFactor = var3;
this.__o = var4;
this.attackEnvelopeFactor = 0;
this.__o_180();
}
RawPcmStream(AudioBuffer var1, int var2, int var3) {
super.sound = var1;
this.start = var1.start;
this.end = var1.end;
this.enableEffects = var1.bool;
this.notePitchFactor = var2;
this.noteVelocityFactor = var3;
this.__o = 8192;
this.attackEnvelopeFactor = 0;
this.__o_180();
}
void __o_180() {
this.__u = this.noteVelocityFactor;
this.rightChannelPan = method2603(this.noteVelocityFactor, this.__o);
this.leftChannelPan = method2494(this.noteVelocityFactor, this.__o);
}
protected PcmStream firstSubStream() {
return null;
}
protected PcmStream nextSubStream() {
return null;
}
protected int __l_171() {
return this.noteVelocityFactor == 0 && this.surfaceOffsetY == 0?0:1;
}
public synchronized void __e_172(int[] var1, int var2, int var3) {
if(this.noteVelocityFactor == 0 && this.surfaceOffsetY == 0) {
this.__d_173(var3);
} else {
AudioBuffer var4 = (AudioBuffer)super.sound;
int var5 = this.start << 8;
int var6 = this.end << 8;
int var7 = var4.samples.length << 8;
int var8 = var6 - var5;
if(var8 <= 0) {
this.loopValue = 0;
}
int var9 = var2;
var3 += var2;
if(this.attackEnvelopeFactor < 0) {
if(this.notePitchFactor <= 0) {
this.__b_189();
this.remove();
return;
}
this.attackEnvelopeFactor = 0;
}
if(this.attackEnvelopeFactor >= var7) {
if(this.notePitchFactor >= 0) {
this.__b_189();
this.remove();
return;
}
this.attackEnvelopeFactor = var7 - 1;
}
if(this.loopValue < 0) {
if(this.enableEffects) {
if(this.notePitchFactor < 0) {
var9 = this.__ap_203(var1, var2, var5, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
this.attackEnvelopeFactor = var5 + var5 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
}
while(true) {
var9 = this.__ad_202(var1, var9, var6, var3, var4.samples[this.end - 1]);
if(this.attackEnvelopeFactor < var6) {
return;
}
this.attackEnvelopeFactor = var6 + var6 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
var9 = this.__ap_203(var1, var9, var5, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
this.attackEnvelopeFactor = var5 + var5 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
}
}
if(this.notePitchFactor < 0) {
while(true) {
var9 = this.__ap_203(var1, var9, var5, var3, var4.samples[this.end - 1]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
this.attackEnvelopeFactor = var6 - 1 - (var6 - 1 - this.attackEnvelopeFactor) % var8;
}
}
while(true) {
var9 = this.__ad_202(var1, var9, var6, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor < var6) {
return;
}
this.attackEnvelopeFactor = var5 + (this.attackEnvelopeFactor - var5) % var8;
}
}
if(this.loopValue > 0) {
if(this.enableEffects) {
label118: {
if(this.notePitchFactor < 0) {
var9 = this.__ap_203(var1, var2, var5, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
this.attackEnvelopeFactor = var5 + var5 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
if(--this.loopValue == 0) {
break label118;
}
}
do {
var9 = this.__ad_202(var1, var9, var6, var3, var4.samples[this.end - 1]);
if(this.attackEnvelopeFactor < var6) {
return;
}
this.attackEnvelopeFactor = var6 + var6 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
if(--this.loopValue == 0) {
break;
}
var9 = this.__ap_203(var1, var9, var5, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
this.attackEnvelopeFactor = var5 + var5 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
} while(--this.loopValue != 0);
}
} else {
int var10;
if(this.notePitchFactor < 0) {
while(true) {
var9 = this.__ap_203(var1, var9, var5, var3, var4.samples[this.end - 1]);
if(this.attackEnvelopeFactor >= var5) {
return;
}
var10 = (var6 - 1 - this.attackEnvelopeFactor) / var8;
if(var10 >= this.loopValue) {
this.attackEnvelopeFactor += var8 * this.loopValue;
this.loopValue = 0;
break;
}
this.attackEnvelopeFactor += var8 * var10;
this.loopValue -= var10;
}
} else {
while(true) {
var9 = this.__ad_202(var1, var9, var6, var3, var4.samples[this.start]);
if(this.attackEnvelopeFactor < var6) {
return;
}
var10 = (this.attackEnvelopeFactor - var5) / var8;
if(var10 >= this.loopValue) {
this.attackEnvelopeFactor -= var8 * this.loopValue;
this.loopValue = 0;
break;
}
this.attackEnvelopeFactor -= var8 * var10;
this.loopValue -= var10;
}
}
}
}
if(this.notePitchFactor < 0) {
this.__ap_203(var1, var9, 0, var3, 0);
if(this.attackEnvelopeFactor < 0) {
this.attackEnvelopeFactor = -1;
this.__b_189();
this.remove();
}
} else {
this.__ad_202(var1, var9, var7, var3, 0);
if(this.attackEnvelopeFactor >= var7) {
this.attackEnvelopeFactor = var7;
this.__b_189();
this.remove();
}
}
}
}
public synchronized void setLoopOnSample(int loopMode) {
this.loopValue = loopMode;
}
public synchronized void __d_173(int var1) {
if(this.surfaceOffsetY > 0) {
if(var1 >= this.surfaceOffsetY) {
if(this.noteVelocityFactor == Integer.MIN_VALUE) {
this.noteVelocityFactor = 0;
this.leftChannelPan = 0;
this.rightChannelPan = 0;
this.__u = 0;
this.remove();
var1 = this.surfaceOffsetY;
}
this.surfaceOffsetY = 0;
this.__o_180();
} else {
this.__u += this.__i * var1;
this.rightChannelPan += this.__a * var1;
this.leftChannelPan += this.__z * var1;
this.surfaceOffsetY -= var1;
}
}
AudioBuffer var2 = (AudioBuffer)super.sound;
int var3 = this.start << 8;
int var4 = this.end << 8;
int var5 = var2.samples.length << 8;
int var6 = var4 - var3;
if(var6 <= 0) {
this.loopValue = 0;
}
if(this.attackEnvelopeFactor < 0) {
if(this.notePitchFactor <= 0) {
this.__b_189();
this.remove();
return;
}
this.attackEnvelopeFactor = 0;
}
if(this.attackEnvelopeFactor >= var5) {
if(this.notePitchFactor >= 0) {
this.__b_189();
this.remove();
return;
}
this.attackEnvelopeFactor = var5 - 1;
}
this.attackEnvelopeFactor += this.notePitchFactor * var1;
if(this.loopValue < 0) {
if(!this.enableEffects) {
if(this.notePitchFactor < 0) {
if(this.attackEnvelopeFactor >= var3) {
return;
}
this.attackEnvelopeFactor = var4 - 1 - (var4 - 1 - this.attackEnvelopeFactor) % var6;
} else {
if(this.attackEnvelopeFactor < var4) {
return;
}
this.attackEnvelopeFactor = var3 + (this.attackEnvelopeFactor - var3) % var6;
}
} else {
if(this.notePitchFactor < 0) {
if(this.attackEnvelopeFactor >= var3) {
return;
}
this.attackEnvelopeFactor = var3 + var3 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
}
while(this.attackEnvelopeFactor >= var4) {
this.attackEnvelopeFactor = var4 + var4 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
if(this.attackEnvelopeFactor >= var3) {
return;
}
this.attackEnvelopeFactor = var3 + var3 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
}
}
} else {
if(this.loopValue > 0) {
if(this.enableEffects) {
label113: {
if(this.notePitchFactor < 0) {
if(this.attackEnvelopeFactor >= var3) {
return;
}
this.attackEnvelopeFactor = var3 + var3 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
if(--this.loopValue == 0) {
break label113;
}
}
do {
if(this.attackEnvelopeFactor < var4) {
return;
}
this.attackEnvelopeFactor = var4 + var4 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
if(--this.loopValue == 0) {
break;
}
if(this.attackEnvelopeFactor >= var3) {
return;
}
this.attackEnvelopeFactor = var3 + var3 - 1 - this.attackEnvelopeFactor;
this.notePitchFactor = -this.notePitchFactor;
} while(--this.loopValue != 0);
}
} else {
int var7;
if(this.notePitchFactor < 0) {
if(this.attackEnvelopeFactor >= var3) {
return;
}
var7 = (var4 - 1 - this.attackEnvelopeFactor) / var6;
if(var7 < this.loopValue) {
this.attackEnvelopeFactor += var6 * var7;
this.loopValue -= var7;
return;
}
this.attackEnvelopeFactor += var6 * this.loopValue;
this.loopValue = 0;
} else {
if(this.attackEnvelopeFactor < var4) {
return;
}
var7 = (this.attackEnvelopeFactor - var3) / var6;
if(var7 < this.loopValue) {
this.attackEnvelopeFactor -= var6 * var7;
this.loopValue -= var7;
return;
}
this.attackEnvelopeFactor -= var6 * this.loopValue;
this.loopValue = 0;
}
}
}
if(this.notePitchFactor < 0) {
if(this.attackEnvelopeFactor < 0) {
this.attackEnvelopeFactor = -1;
this.__b_189();
this.remove();
}
} else if(this.attackEnvelopeFactor >= var5) {
this.attackEnvelopeFactor = var5;
this.__b_189();
this.remove();
}
}
}
public synchronized void __a_182(int var1) {
this.__j_184(var1 << 6, this.__t_186());
}
synchronized void __z_183(int var1) {
this.__j_184(var1, this.__t_186());
}
synchronized void __j_184(int var1, int var2) {
this.noteVelocityFactor = var1;
this.__o = var2;
this.surfaceOffsetY = 0;
this.__o_180();
}
public synchronized int __s_185() {
return this.noteVelocityFactor == Integer.MIN_VALUE?0:this.noteVelocityFactor;
}
public synchronized int __t_186() {
return this.__o < 0?-1:this.__o;
}
public synchronized void __y_187(int var1) {
int var2 = ((AudioBuffer)super.sound).samples.length << 8;
if(var1 < -1) {
var1 = -1;
}
if(var1 > var2) {
var1 = var2;
}
this.attackEnvelopeFactor = var1;
}
public synchronized void __h_188() {
this.notePitchFactor = (this.notePitchFactor ^ this.notePitchFactor >> 31) + (this.notePitchFactor >>> 31);
this.notePitchFactor = -this.notePitchFactor;
}
void __b_189() {
if(this.surfaceOffsetY != 0) {
if(this.noteVelocityFactor == Integer.MIN_VALUE) {
this.noteVelocityFactor = 0;
}
this.surfaceOffsetY = 0;
this.__o_180();
}
}
public synchronized void __c_190(int var1, int var2) {
this.__p_191(var1, var2, this.__t_186());
}
public synchronized void __p_191(int var1, int var2, int var3) {
if(var1 == 0) {
this.__j_184(var2, var3);
} else {
int var4 = method2603(var2, var3);
int var5 = method2494(var2, var3);
if(var4 == this.rightChannelPan && var5 == this.leftChannelPan) {
this.surfaceOffsetY = 0;
} else {
int var6 = var2 - this.__u;
if(this.__u - var2 > var6) {
var6 = this.__u - var2;
}
if(var4 - this.rightChannelPan > var6) {
var6 = var4 - this.rightChannelPan;
}
if(this.rightChannelPan - var4 > var6) {
var6 = this.rightChannelPan - var4;
}
if(var5 - this.leftChannelPan > var6) {
var6 = var5 - this.leftChannelPan;
}
if(this.leftChannelPan - var5 > var6) {
var6 = this.leftChannelPan - var5;
}
if(var1 > var6) {
var1 = var6;
}
this.surfaceOffsetY = var1;
this.noteVelocityFactor = var2;
this.__o = var3;
this.__i = (var2 - this.__u) / var1;
this.__a = (var4 - this.rightChannelPan) / var1;
this.__z = (var5 - this.leftChannelPan) / var1;
}
}
}
public synchronized void __v_192(int var1) {
if(var1 == 0) {
this.__z_183(0);
this.remove();
} else if(this.rightChannelPan == 0 && this.leftChannelPan == 0) {
this.surfaceOffsetY = 0;
this.noteVelocityFactor = 0;
this.__u = 0;
this.remove();
} else {
int var2 = -this.__u;
if(this.__u > var2) {
var2 = this.__u;
}
if(-this.rightChannelPan > var2) {
var2 = -this.rightChannelPan;
}
if(this.rightChannelPan > var2) {
var2 = this.rightChannelPan;
}
if(-this.leftChannelPan > var2) {
var2 = -this.leftChannelPan;
}
if(this.leftChannelPan > var2) {
var2 = this.leftChannelPan;
}
if(var1 > var2) {
var1 = var2;
}
this.surfaceOffsetY = var1;
this.noteVelocityFactor = Integer.MIN_VALUE;
this.__i = -this.__u / var1;
this.__a = -this.rightChannelPan / var1;
this.__z = -this.leftChannelPan / var1;
}
}
public synchronized void __ah_193(int var1) {
if(this.notePitchFactor < 0) {
this.notePitchFactor = -var1;
} else {
this.notePitchFactor = var1;
}
}
public synchronized int __ab_194() {
return this.notePitchFactor < 0?-this.notePitchFactor:this.notePitchFactor;
}
public boolean __ae_195() {
return this.attackEnvelopeFactor < 0 || this.attackEnvelopeFactor >= ((AudioBuffer)super.sound).samples.length << 8;
}
public boolean __at_196() {
return this.surfaceOffsetY != 0;
}
int __ad_202(int[] var1, int var2, int var3, int var4, int var5) {
while(true) {
if(this.surfaceOffsetY > 0) {
int var6 = var2 + this.surfaceOffsetY;
if(var6 > var4) {
var6 = var4;
}
this.surfaceOffsetY += var2;
if(this.notePitchFactor == 256 && (this.attackEnvelopeFactor & 255) == 0) {
if(AudioConstants.isStereo) {
var2 = method2533(0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, this.__a, this.__z, 0, var6, var3, this);
} else {
var2 = method2532(((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, this.__i, 0, var6, var3, this);
}
} else if(AudioConstants.isStereo) {
var2 = method2504(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, this.__a, this.__z, 0, var6, var3, this, this.notePitchFactor, var5);
} else {
var2 = method2536(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, this.__i, 0, var6, var3, this, this.notePitchFactor, var5);
}
this.surfaceOffsetY -= var2;
if(this.surfaceOffsetY != 0) {
return var2;
}
if(!this.__au_204()) {
continue;
}
return var4;
}
if(this.notePitchFactor == 256 && (this.attackEnvelopeFactor & 255) == 0) {
if(AudioConstants.isStereo) {
return method2525(0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, 0, var4, var3, this);
}
return method2563(((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, 0, var4, var3, this);
}
if(AudioConstants.isStereo) {
return method2529(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, 0, var4, var3, this, this.notePitchFactor, var5);
}
return method2528(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, 0, var4, var3, this, this.notePitchFactor, var5);
}
}
int __ap_203(int[] var1, int var2, int var3, int var4, int var5) {
while(true) {
if(this.surfaceOffsetY > 0) {
int var6 = var2 + this.surfaceOffsetY;
if(var6 > var4) {
var6 = var4;
}
this.surfaceOffsetY += var2;
if(this.notePitchFactor == -256 && (this.attackEnvelopeFactor & 255) == 0) {
if(AudioConstants.isStereo) {
var2 = method2547(0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, this.__a, this.__z, 0, var6, var3, this);
} else {
var2 = method2534(((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, this.__i, 0, var6, var3, this);
}
} else if(AudioConstants.isStereo) {
var2 = method2624(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, this.__a, this.__z, 0, var6, var3, this, this.notePitchFactor, var5);
} else {
var2 = method2538(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, this.__i, 0, var6, var3, this, this.notePitchFactor, var5);
}
this.surfaceOffsetY -= var2;
if(this.surfaceOffsetY != 0) {
return var2;
}
if(!this.__au_204()) {
continue;
}
return var4;
}
if(this.notePitchFactor == -256 && (this.attackEnvelopeFactor & 255) == 0) {
if(AudioConstants.isStereo) {
return method2496(0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, 0, var4, var3, this);
}
return method2636(((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, 0, var4, var3, this);
}
if(AudioConstants.isStereo) {
return method2531(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.rightChannelPan, this.leftChannelPan, 0, var4, var3, this, this.notePitchFactor, var5);
}
return method2509(0, 0, ((AudioBuffer)super.sound).samples, var1, this.attackEnvelopeFactor, var2, this.__u, 0, var4, var3, this, this.notePitchFactor, var5);
}
}
int __az_179() {
int var1 = this.__u * 3 >> 6;
var1 = (var1 ^ var1 >> 31) + (var1 >>> 31);
if(this.loopValue == 0) {
var1 -= var1 * this.attackEnvelopeFactor / (((AudioBuffer)super.sound).samples.length << 8);
} else if(this.loopValue >= 0) {
var1 -= var1 * this.start / ((AudioBuffer)super.sound).samples.length;
}
return var1 > 255?255:var1;
}
boolean __au_204() {
int var1 = this.noteVelocityFactor;
int var2;
int var3;
if(var1 == Integer.MIN_VALUE) {
var3 = 0;
var2 = 0;
var1 = 0;
} else {
var2 = method2603(var1, this.__o);
var3 = method2494(var1, this.__o);
}
if(var1 == this.__u && var2 == this.rightChannelPan && var3 == this.leftChannelPan) {
if(this.noteVelocityFactor == Integer.MIN_VALUE) {
this.noteVelocityFactor = 0;
this.leftChannelPan = 0;
this.rightChannelPan = 0;
this.__u = 0;
this.remove();
return true;
} else {
this.__o_180();
return false;
}
} else {
if(this.__u < var1) {
this.__i = 1;
this.surfaceOffsetY = var1 - this.__u;
} else if(this.__u > var1) {
this.__i = -1;
this.surfaceOffsetY = this.__u - var1;
} else {
this.__i = 0;
}
if(this.rightChannelPan < var2) {
this.__a = 1;
if(this.surfaceOffsetY == 0 || this.surfaceOffsetY > var2 - this.rightChannelPan) {
this.surfaceOffsetY = var2 - this.rightChannelPan;
}
} else if(this.rightChannelPan > var2) {
this.__a = -1;
if(this.surfaceOffsetY == 0 || this.surfaceOffsetY > this.rightChannelPan - var2) {
this.surfaceOffsetY = this.rightChannelPan - var2;
}
} else {
this.__a = 0;
}
if(this.leftChannelPan < var3) {
this.__z = 1;
if(this.surfaceOffsetY == 0 || this.surfaceOffsetY > var3 - this.leftChannelPan) {
this.surfaceOffsetY = var3 - this.leftChannelPan;
}
} else if(this.leftChannelPan > var3) {
this.__z = -1;
if(this.surfaceOffsetY == 0 || this.surfaceOffsetY > this.leftChannelPan - var3) {
this.surfaceOffsetY = this.leftChannelPan - var3;
}
} else {
this.__z = 0;
}
return false;
}
}
static int method2603(int var0, int var1) {
return var1 < 0?var0:(int)((double)var0 * Math.sqrt((double)(16384 - var1) * 1.220703125E-4D) + 0.5D);
}
static int method2494(int var0, int var1) {
return var1 < 0?-var0:(int)((double)var0 * Math.sqrt((double)var1 * 1.220703125E-4D) + 0.5D);
}
public static RawPcmStream method2497(AudioBuffer rawSample, int var1, int var2) {
return rawSample.samples != null && rawSample.samples.length != 0?new RawPcmStream(rawSample, (int)((long)rawSample.sampleRate * 256L * (long)var1 / (long)(AudioConstants.systemSampleRate * 100)), var2 << 6):null;
}
public static RawPcmStream method2524(AudioBuffer rawSample, int samplePitch, int velocityLeftChannel, int velocityRightChannel) {
return rawSample.samples != null && rawSample.samples.length != 0?new RawPcmStream(rawSample, samplePitch, velocityLeftChannel, velocityRightChannel):null;
}
static int method2563(byte[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, RawPcmStream var8) {
var2 >>= 8;
var7 >>= 8;
var4 <<= 2;
if((var5 = var3 + var7 - var2) > var6) {
var5 = var6;
}
int var9;
for(var5 -= 3; var3 < var5; var1[var9] += var0[var2++] * var4) {
var9 = var3++;
var1[var9] += var0[var2++] * var4;
var9 = var3++;
var1[var9] += var0[var2++] * var4;
var9 = var3++;
var1[var9] += var0[var2++] * var4;
var9 = var3++;
}
for(var5 += 3; var3 < var5; var1[var9] += var0[var2++] * var4) {
var9 = var3++;
}
var8.attackEnvelopeFactor = var2 << 8;
return var3;
}
static int method2525(int var0, byte[] var1, int[] var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, RawPcmStream var10) {
var3 >>= 8;
var9 >>= 8;
var5 <<= 2;
var6 <<= 2;
if((var7 = var4 + var9 - var3) > var8) {
var7 = var8;
}
var4 <<= 1;
var7 <<= 1;
int var11;
byte var12;
for(var7 -= 6; var4 < var7; var2[var11] += var12 * var6) {
var12 = var1[var3++];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3++];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3++];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3++];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
}
for(var7 += 6; var4 < var7; var2[var11] += var12 * var6) {
var12 = var1[var3++];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
}
var10.attackEnvelopeFactor = var3 << 8;
return var4 >> 1;
}
static int method2636(byte[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, RawPcmStream var8) {
var2 >>= 8;
var7 >>= 8;
var4 <<= 2;
if((var5 = var3 + var2 - (var7 - 1)) > var6) {
var5 = var6;
}
int var9;
for(var5 -= 3; var3 < var5; var1[var9] += var0[var2--] * var4) {
var9 = var3++;
var1[var9] += var0[var2--] * var4;
var9 = var3++;
var1[var9] += var0[var2--] * var4;
var9 = var3++;
var1[var9] += var0[var2--] * var4;
var9 = var3++;
}
for(var5 += 3; var3 < var5; var1[var9] += var0[var2--] * var4) {
var9 = var3++;
}
var8.attackEnvelopeFactor = var2 << 8;
return var3;
}
static int method2496(int var0, byte[] var1, int[] var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, RawPcmStream var10) {
var3 >>= 8;
var9 >>= 8;
var5 <<= 2;
var6 <<= 2;
if((var7 = var3 + var4 - (var9 - 1)) > var8) {
var7 = var8;
}
var4 <<= 1;
var7 <<= 1;
int var11;
byte var12;
for(var7 -= 6; var4 < var7; var2[var11] += var12 * var6) {
var12 = var1[var3--];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3--];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3--];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
var2[var11] += var12 * var6;
var12 = var1[var3--];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
}
for(var7 += 6; var4 < var7; var2[var11] += var12 * var6) {
var12 = var1[var3--];
var11 = var4++;
var2[var11] += var12 * var5;
var11 = var4++;
}
var10.attackEnvelopeFactor = var3 << 8;
return var4 >> 1;
}
static int method2528(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, RawPcmStream var10, int var11, int var12) {
if(var11 == 0 || (var7 = var5 + (var11 + (var9 - var4) - 257) / var11) > var8) {
var7 = var8;
}
byte var13;
int var14;
while(var5 < var7) {
var1 = var4 >> 8;
var13 = var2[var1];
var14 = var5++;
var3[var14] += ((var13 << 8) + (var2[var1 + 1] - var13) * (var4 & 255)) * var6 >> 6;
var4 += var11;
}
if(var11 == 0 || (var7 = var5 + (var11 + (var9 - var4) - 1) / var11) > var8) {
var7 = var8;
}
for(var1 = var12; var5 < var7; var4 += var11) {
var13 = var2[var4 >> 8];
var14 = var5++;
var3[var14] += ((var13 << 8) + (var1 - var13) * (var4 & 255)) * var6 >> 6;
}
var10.attackEnvelopeFactor = var4;
return var5;
}
static int method2529(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, RawPcmStream var11, int var12, int var13) {
if(var12 == 0 || (var8 = var5 + (var10 - var4 + var12 - 257) / var12) > var9) {
var8 = var9;
}
var5 <<= 1;
byte var14;
int var15;
for(var8 <<= 1; var5 < var8; var4 += var12) {
var1 = var4 >> 8;
var14 = var2[var1];
var0 = (var14 << 8) + (var4 & 255) * (var2[var1 + 1] - var14);
var15 = var5++;
var3[var15] += var0 * var6 >> 6;
var15 = var5++;
var3[var15] += var0 * var7 >> 6;
}
if(var12 == 0 || (var8 = (var5 >> 1) + (var10 - var4 + var12 - 1) / var12) > var9) {
var8 = var9;
}
var8 <<= 1;
for(var1 = var13; var5 < var8; var4 += var12) {
var14 = var2[var4 >> 8];
var0 = (var14 << 8) + (var1 - var14) * (var4 & 255);
var15 = var5++;
var3[var15] += var0 * var6 >> 6;
var15 = var5++;
var3[var15] += var0 * var7 >> 6;
}
var11.attackEnvelopeFactor = var4;
return var5 >> 1;
}
static int method2509(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, RawPcmStream var10, int var11, int var12) {
if(var11 == 0 || (var7 = var5 + (var11 + (var9 + 256 - var4)) / var11) > var8) {
var7 = var8;
}
int var13;
while(var5 < var7) {
var1 = var4 >> 8;
byte var14 = var2[var1 - 1];
var13 = var5++;
var3[var13] += ((var14 << 8) + (var2[var1] - var14) * (var4 & 255)) * var6 >> 6;
var4 += var11;
}
if(var11 == 0 || (var7 = var5 + (var11 + (var9 - var4)) / var11) > var8) {
var7 = var8;
}
var0 = var12;
for(var1 = var11; var5 < var7; var4 += var1) {
var13 = var5++;
var3[var13] += ((var0 << 8) + (var2[var4 >> 8] - var0) * (var4 & 255)) * var6 >> 6;
}
var10.attackEnvelopeFactor = var4;
return var5;
}
static int method2531(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, RawPcmStream var11, int var12, int var13) {
if(var12 == 0 || (var8 = var5 + (var10 + 256 - var4 + var12) / var12) > var9) {
var8 = var9;
}
var5 <<= 1;
int var14;
for(var8 <<= 1; var5 < var8; var4 += var12) {
var1 = var4 >> 8;
byte var15 = var2[var1 - 1];
var0 = (var2[var1] - var15) * (var4 & 255) + (var15 << 8);
var14 = var5++;
var3[var14] += var0 * var6 >> 6;
var14 = var5++;
var3[var14] += var0 * var7 >> 6;
}
if(var12 == 0 || (var8 = (var5 >> 1) + (var10 - var4 + var12) / var12) > var9) {
var8 = var9;
}
var8 <<= 1;
for(var1 = var13; var5 < var8; var4 += var12) {
var0 = (var1 << 8) + (var4 & 255) * (var2[var4 >> 8] - var1);
var14 = var5++;
var3[var14] += var0 * var6 >> 6;
var14 = var5++;
var3[var14] += var0 * var7 >> 6;
}
var11.attackEnvelopeFactor = var4;
return var5 >> 1;
}
static int method2532(byte[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, RawPcmStream var9) {
var2 >>= 8;
var8 >>= 8;
var4 <<= 2;
var5 <<= 2;
if((var6 = var3 + var8 - var2) > var7) {
var6 = var7;
}
var9.rightChannelPan += var9.__a * (var6 - var3);
var9.leftChannelPan += var9.__z * (var6 - var3);
int var10;
for(var6 -= 3; var3 < var6; var4 += var5) {
var10 = var3++;
var1[var10] += var0[var2++] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2++] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2++] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2++] * var4;
}
for(var6 += 3; var3 < var6; var4 += var5) {
var10 = var3++;
var1[var10] += var0[var2++] * var4;
}
var9.__u = var4 >> 2;
var9.attackEnvelopeFactor = var2 << 8;
return var3;
}
static int method2533(int var0, byte[] var1, int[] var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, RawPcmStream var12) {
var3 >>= 8;
var11 >>= 8;
var5 <<= 2;
var6 <<= 2;
var7 <<= 2;
var8 <<= 2;
if((var9 = var11 + var4 - var3) > var10) {
var9 = var10;
}
var12.__u += var12.__i * (var9 - var4);
var4 <<= 1;
var9 <<= 1;
byte var13;
int var14;
for(var9 -= 6; var4 < var9; var6 += var8) {
var13 = var1[var3++];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3++];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3++];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3++];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
}
for(var9 += 6; var4 < var9; var6 += var8) {
var13 = var1[var3++];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
}
var12.rightChannelPan = var5 >> 2;
var12.leftChannelPan = var6 >> 2;
var12.attackEnvelopeFactor = var3 << 8;
return var4 >> 1;
}
static int method2534(byte[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, RawPcmStream var9) {
var2 >>= 8;
var8 >>= 8;
var4 <<= 2;
var5 <<= 2;
if((var6 = var3 + var2 - (var8 - 1)) > var7) {
var6 = var7;
}
var9.rightChannelPan += var9.__a * (var6 - var3);
var9.leftChannelPan += var9.__z * (var6 - var3);
int var10;
for(var6 -= 3; var3 < var6; var4 += var5) {
var10 = var3++;
var1[var10] += var0[var2--] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2--] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2--] * var4;
var4 += var5;
var10 = var3++;
var1[var10] += var0[var2--] * var4;
}
for(var6 += 3; var3 < var6; var4 += var5) {
var10 = var3++;
var1[var10] += var0[var2--] * var4;
}
var9.__u = var4 >> 2;
var9.attackEnvelopeFactor = var2 << 8;
return var3;
}
static int method2547(int var0, byte[] var1, int[] var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, RawPcmStream var12) {
var3 >>= 8;
var11 >>= 8;
var5 <<= 2;
var6 <<= 2;
var7 <<= 2;
var8 <<= 2;
if((var9 = var3 + var4 - (var11 - 1)) > var10) {
var9 = var10;
}
var12.__u += var12.__i * (var9 - var4);
var4 <<= 1;
var9 <<= 1;
byte var13;
int var14;
for(var9 -= 6; var4 < var9; var6 += var8) {
var13 = var1[var3--];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3--];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3--];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
var6 += var8;
var13 = var1[var3--];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
}
for(var9 += 6; var4 < var9; var6 += var8) {
var13 = var1[var3--];
var14 = var4++;
var2[var14] += var13 * var5;
var5 += var7;
var14 = var4++;
var2[var14] += var13 * var6;
}
var12.rightChannelPan = var5 >> 2;
var12.leftChannelPan = var6 >> 2;
var12.attackEnvelopeFactor = var3 << 8;
return var4 >> 1;
}
static int method2536(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, RawPcmStream var11, int var12, int var13) {
var11.rightChannelPan -= var11.__a * var5;
var11.leftChannelPan -= var11.__z * var5;
if(var12 == 0 || (var8 = var5 + (var10 - var4 + var12 - 257) / var12) > var9) {
var8 = var9;
}
byte var14;
int var15;
while(var5 < var8) {
var1 = var4 >> 8;
var14 = var2[var1];
var15 = var5++;
var3[var15] += ((var14 << 8) + (var2[var1 + 1] - var14) * (var4 & 255)) * var6 >> 6;
var6 += var7;
var4 += var12;
}
if(var12 == 0 || (var8 = var5 + (var10 - var4 + var12 - 1) / var12) > var9) {
var8 = var9;
}
for(var1 = var13; var5 < var8; var4 += var12) {
var14 = var2[var4 >> 8];
var15 = var5++;
var3[var15] += ((var14 << 8) + (var1 - var14) * (var4 & 255)) * var6 >> 6;
var6 += var7;
}
var11.rightChannelPan += var11.__a * var5;
var11.leftChannelPan += var11.__z * var5;
var11.__u = var6;
var11.attackEnvelopeFactor = var4;
return var5;
}
static int method2504(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, int var12, RawPcmStream var13, int var14, int var15) {
var13.__u -= var5 * var13.__i;
if(var14 == 0 || (var10 = var5 + (var12 - var4 + var14 - 257) / var14) > var11) {
var10 = var11;
}
var5 <<= 1;
byte var16;
int var17;
for(var10 <<= 1; var5 < var10; var4 += var14) {
var1 = var4 >> 8;
var16 = var2[var1];
var0 = (var16 << 8) + (var4 & 255) * (var2[var1 + 1] - var16);
var17 = var5++;
var3[var17] += var0 * var6 >> 6;
var6 += var8;
var17 = var5++;
var3[var17] += var0 * var7 >> 6;
var7 += var9;
}
if(var14 == 0 || (var10 = (var5 >> 1) + (var12 - var4 + var14 - 1) / var14) > var11) {
var10 = var11;
}
var10 <<= 1;
for(var1 = var15; var5 < var10; var4 += var14) {
var16 = var2[var4 >> 8];
var0 = (var16 << 8) + (var1 - var16) * (var4 & 255);
var17 = var5++;
var3[var17] += var0 * var6 >> 6;
var6 += var8;
var17 = var5++;
var3[var17] += var0 * var7 >> 6;
var7 += var9;
}
var5 >>= 1;
var13.__u += var13.__i * var5;
var13.rightChannelPan = var6;
var13.leftChannelPan = var7;
var13.attackEnvelopeFactor = var4;
return var5;
}
static int method2538(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, RawPcmStream var11, int var12, int var13) {
var11.rightChannelPan -= var11.__a * var5;
var11.leftChannelPan -= var11.__z * var5;
if(var12 == 0 || (var8 = var5 + (var10 + 256 - var4 + var12) / var12) > var9) {
var8 = var9;
}
int var14;
while(var5 < var8) {
var1 = var4 >> 8;
byte var15 = var2[var1 - 1];
var14 = var5++;
var3[var14] += ((var15 << 8) + (var2[var1] - var15) * (var4 & 255)) * var6 >> 6;
var6 += var7;
var4 += var12;
}
if(var12 == 0 || (var8 = var5 + (var10 - var4 + var12) / var12) > var9) {
var8 = var9;
}
var0 = var13;
for(var1 = var12; var5 < var8; var4 += var1) {
var14 = var5++;
var3[var14] += ((var0 << 8) + (var2[var4 >> 8] - var0) * (var4 & 255)) * var6 >> 6;
var6 += var7;
}
var11.rightChannelPan += var11.__a * var5;
var11.leftChannelPan += var11.__z * var5;
var11.__u = var6;
var11.attackEnvelopeFactor = var4;
return var5;
}
static int method2624(int var0, int var1, byte[] var2, int[] var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, int var12, RawPcmStream var13, int var14, int var15) {
var13.__u -= var5 * var13.__i;
if(var14 == 0 || (var10 = var5 + (var12 + 256 - var4 + var14) / var14) > var11) {
var10 = var11;
}
var5 <<= 1;
int var16;
for(var10 <<= 1; var5 < var10; var4 += var14) {
var1 = var4 >> 8;
byte var17 = var2[var1 - 1];
var0 = (var2[var1] - var17) * (var4 & 255) + (var17 << 8);
var16 = var5++;
var3[var16] += var0 * var6 >> 6;
var6 += var8;
var16 = var5++;
var3[var16] += var0 * var7 >> 6;
var7 += var9;
}
if(var14 == 0 || (var10 = (var5 >> 1) + (var12 - var4 + var14) / var14) > var11) {
var10 = var11;
}
var10 <<= 1;
for(var1 = var15; var5 < var10; var4 += var14) {
var0 = (var1 << 8) + (var4 & 255) * (var2[var4 >> 8] - var1);
var16 = var5++;
var3[var16] += var0 * var6 >> 6;
var6 += var8;
var16 = var5++;
var3[var16] += var0 * var7 >> 6;
var7 += var9;
}
var5 >>= 1;
var13.__u += var13.__i * var5;
var13.rightChannelPan = var6;
var13.leftChannelPan = var7;
var13.attackEnvelopeFactor = var4;
return var5;
}
}
|
[
"[email protected]"
] | |
75805e1f262b4afed15130193ab07f655e50ee16
|
2ec5fe439c37d070f46bf2163a377c923d049221
|
/web/src/main/java/org/faith/management/web/action/UpdateAction.java
|
f6283545cff7053aa507f52da146a72a6e1ffbd5
|
[] |
no_license
|
javy-liu/user-management
|
f9111db85a1932affa44e6ec40a5266c968d4369
|
96fc5c089b5e9250cafe54c6ff67f0e0e95c2de3
|
refs/heads/master
| 2021-01-22T18:23:21.004784 | 2013-12-06T07:41:33 | 2013-12-06T07:41:33 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,831 |
java
|
package org.faith.management.web.action;
import org.faith.management.core.entity.domain.User;
import org.faith.management.core.exception.database.NotFoundException;
import org.faith.management.service.UserService;
import org.faith.management.service.factory.ServiceFactory;
import org.faith.management.web.common.Router;
import org.faith.management.web.common.View;
import org.faith.management.web.helper.MessageHelper;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 更新
*
* @author faith
* @since 0.0.1
*/
@WebServlet(name = "UpdateServlet", urlPatterns = Router.update)
public class UpdateAction extends HttpServlet {
private UserService userService = ServiceFactory.getUserService();
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String username = req.getParameter("username");
User user = null;
try {
user = userService.readByUsername(username);
} catch (NotFoundException e) {
e.printStackTrace();
}
req.setAttribute("user",user);
req.getRequestDispatcher(View.update).forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取值
String username = req.getParameter("username").trim();
String password = req.getParameter("password").trim();
String name = req.getParameter("name").trim();
String confirmPassword = req.getParameter("confirm_password").trim();
// 验证数据 简单验证一下
if (username.length()<5 || username.length()> 8){
MessageHelper.addErrorField("username","账号错误！限制5-8位。",req);
}
if (password.length()<5 || username.length()> 16){
MessageHelper.addErrorField("password","密码错误！限制5-16位。",req);
}
if (!confirmPassword.equals(password)){
MessageHelper.addErrorField("confirm_password","密码不一致。",req);
}
if (name.length() > 7 ){
MessageHelper.addErrorField("name","用户名错误！限制小于7位。",req);
}
if (MessageHelper.hasError(req)){
doGet(req, resp);
return;
}
User user = new User();
user.setUsername(username);
user.setPassword(password);
user.setName(name);
userService.update(user);
MessageHelper.addSuccess("更新成功！",req);
req.getRequestDispatcher(View.update).forward(req,resp);
}
}
|
[
"[email protected]"
] | |
9e2780aea88b51dbbc9e4f36f8e6be038b0bc0f8
|
f000f56d26f3451cbe39df247d4f2dc700332832
|
/java/20190606-HashString/Record.java
|
bcbec6da774ebf6e868b5448a7a63862d4befc5a
|
[] |
no_license
|
longLiveData/Practice
|
bdc5984505b455f14ec73ccae11c12724bdad7c2
|
d563a050ffe78e463e1de10aeacf5b365d537f7f
|
refs/heads/master
| 2021-03-03T05:47:36.752606 | 2020-03-09T04:20:21 | 2020-03-09T04:20:21 | 245,935,960 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 681 |
java
|
package com.hashstring;
public class Record {
private String name;
private String phone;
private String email;
Record(String name, String phone, String email){
this.name = name;
this.phone = phone;
this.email = email;
}
public int hashCode(){
// first, hashcode() function of java
// return this.name.hashCode();
String key = this.name;
int arraySize = 11113;
int hashCode = 0;
for (int i = 0; i < key.length(); i++) {
int letterValue = key.charAt(i) - 96;
hashCode = ((hashCode << 4) + letterValue) % arraySize;
}
return hashCode;
}
}
|
[
"[email protected]"
] | |
c5c69adcd83d20f433c82b4b5d96bfb4acb4e136
|
a7a1d08498272ae1ef060615e9f1ac41e7f0b095
|
/src/main/java/com/saber/test/calculator/Calculator.java
|
41063b072c598be6c7f38f4a7528f3c9df111ee1
|
[] |
no_license
|
saberlee1987/test
|
e8489e65439efcd043f6933668d33042a42b5b5e
|
d12ea04e520d546436921687fb8a90a298ae6648
|
refs/heads/master
| 2023-07-02T17:03:18.479258 | 2021-07-28T14:24:20 | 2021-07-28T14:24:20 | 390,292,399 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,061 |
java
|
package com.saber.test.calculator;
public class Calculator {
private static long sum(Integer num1, Integer num2) {
return num1 + num2;
}
private static long sub(Integer num1, Integer num2) {
return num1 - num2;
}
private static long mul(Integer num1, Integer num2) {
return num1 * num2;
}
private static long div(Integer num1, Integer num2) {
return num1 / num2;
}
public static long calculate(Integer num1, Integer num2, String op) {
switch (op) {
case "+":
case "sum":
case "plus":
case "add":
return sum(num1, num2);
case "-":
case "minus":
case "sub":
return sub(num1, num2);
case "*":
case "mul":
return mul(num1, num2);
case "div":
case "/":
return div(num1, num2);
default:
throw new IllegalArgumentException("operator is Wrong");
}
}
}
|
[
"[email protected]"
] | |
7ac8dd95aafe430d7f7ff12c30af2e4ad1bdd3ac
|
b5964e2c4b065cb26a877c070ab9b3a954428328
|
/ego-portal/src/main/java/com/ego/portal/controller/PageController.java
|
811e60d9ba670367974a952660c76becc58c80b6
|
[] |
no_license
|
pcbrun/ego-parent
|
0f32aabf17809b650937a6abc8cd60cae8a2f3b0
|
24182070f67bd6888ff27a73ad3d7095609a606c
|
refs/heads/master
| 2022-12-22T05:07:15.512373 | 2019-06-17T12:23:12 | 2019-06-17T12:23:12 | 192,259,632 | 0 | 0 | null | 2022-12-16T09:59:14 | 2019-06-17T02:12:31 |
TSQL
|
UTF-8
|
Java
| false | false | 501 |
java
|
package com.ego.portal.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @Auther:pcb
* @Date:19/5/29
* @Description:com.ego.portal.controller
* @version:1.0
*/
@Controller
public class PageController {
@RequestMapping("/")
public String welcome(){
System.out.println("执行了ego-portal");
return "forward:/showBigPic";
}
}
|
[
"[email protected]"
] | |
0ba56aaf4316489c3baaab2c40fd5cbfad8892ff
|
e0c2efe94dad5f0cf240f4f388b1f462f2f13a5f
|
/20200730-자바네트워크/src/com/sist/ann/RequestMapping.java
|
87317fbf21a552a85e60f08898d9dbe82a950543
|
[] |
no_license
|
achoon91/JavaStudy
|
ace03c868006c6dd53c24d9dac69bfaf17cc49ea
|
4d54caab346ccf8e77f04e5949a096fe8152b1ca
|
refs/heads/master
| 2023-02-25T05:55:38.283189 | 2021-02-12T23:19:08 | 2021-02-12T23:19:08 | 273,409,447 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 326 |
java
|
package com.sist.ann;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@Retention(RUNTIME)
@Target(METHOD)
public @interface RequestMapping {
public String value();
}
|
[
"[email protected]"
] | |
3edbd64bddbc674f00929accc47b702b3c7f3708
|
07903403f1229bb6704ab791088bff678cdb9c4a
|
/entity/src/main/java/com/cn/wanxi/entity/projectrequirements/views/TeamHasMemberEntity.java
|
0cef75ea6f7514abb0a34575a3168f4efeb8592b
|
[] |
no_license
|
rains2711/wxevol
|
42ca029d53b1b1be6b7b55facfe5adcbe9f611c6
|
01e6b8ccf0c5a50edc34b75c4898488e65c59c3e
|
refs/heads/master
| 2022-12-21T09:03:47.012146 | 2019-12-21T06:50:31 | 2019-12-21T06:50:31 | 224,943,652 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,542 |
java
|
package com.cn.wanxi.entity.projectrequirements.views;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* team_has_member
*
* @author
*/
@Data
public class TeamHasMemberEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 团队编号
*/
private Long teamId;
/**
* 团队名称
*/
private String teamName;
/**
* 创建日期
*/
private Date teamCreateTime;
/**
* 修改日期
*/
private Date teamUpdateTime;
/**
* 上级团队编号,(0表示无上级)
*/
private Long superiorTeamId;
/**
* 工作日
*/
private Byte workDay;
/**
* 团队状态 备注(1:正常,0:关闭)
*/
private Byte teamStatus;
/**
* 成员编号
*/
private Long memberId;
/**
* 成员名字
*/
private String memberName;
/**
* 创建日期
*/
private Date memberCreateTime;
/**
* 修改日期
*/
private Date memberUpdateTime;
/**
* 成员状态 备注(1:正常,0:删除,2:暂休)
*/
private Byte memberStatus;
/**
* 角色编号
*/
private Integer roleId;
/**
* 备注(团队管理员,队长,开发,审核,测试)
*/
private String roleName;
/**
* 用户编号
*/
private Long userId;
/**
* 暂不详,待考究
*/
private String roleAuthority;
/**
* 用户账号
*/
private String account;
}
|
[
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.