blob_id
stringlengths 40
40
| language
stringclasses 1
value | repo_name
stringlengths 5
132
| path
stringlengths 2
382
| src_encoding
stringclasses 34
values | length_bytes
int64 9
3.8M
| score
float64 1.5
4.94
| int_score
int64 2
5
| detected_licenses
listlengths 0
142
| license_type
stringclasses 2
values | text
stringlengths 9
3.8M
| download_success
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|
db073fb529f48b4e97bf1f3a3e5a0e0c9f0d91dd
|
Java
|
AndreJohannes/MonsterTruck
|
/MonsterTruckBase/src/CollisionHandling/PreCollisionHandler.java
|
UTF-8
| 8,823
| 2.640625
| 3
|
[] |
no_license
|
package CollisionHandling;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.atomic.AtomicReference;
import Auxiliary.EWorldObjects.DynamicTypes;
import Auxiliary.Graph;
import Auxiliary.IVehicleObject;
import Auxiliary.IWorldDynamicObject;
import Auxiliary.IWorldObjectBase;
import Auxiliary.IWorldStaticObject;
import Auxiliary.IWorldTokenObject;
import Auxiliary.Vector2D.Circle;
public class PreCollisionHandler<T> implements Runnable {
private static double MARGIN = 20;
private static double INNER_DISTANCE_MARGIN = 1000;
private static double OUTER_DISTANCE_MARGIN = 2000;
private final SynchronousQueue<double[]> inputQueue;
private final List<IWorldStaticObject<T>> staticObjectList;
private final List<IWorldDynamicObject<T>> dynamicObjectList;
private final List<IVehicleObject<T>> vehicleObjectList;
private final List<IWorldTokenObject<T>> tokenObjectList;
private final AtomicReference<Graph<IWorldObjectBase<T>>> graph = new AtomicReference<Graph<IWorldObjectBase<T>>>(
new Graph<IWorldObjectBase<T>>());
private final AtomicReference<List<IWorldObjectBase<T>>> visibleObjects = new AtomicReference<List<IWorldObjectBase<T>>>(
new LinkedList<IWorldObjectBase<T>>());
public PreCollisionHandler(
List<IWorldStaticObject<T>> staticObjectInputList,
List<IWorldDynamicObject<T>> dynamicObjectInputList,
List<IWorldTokenObject<T>> tokenObjectInputList,
List<IVehicleObject<T>> vehicleObjectList) {
this.inputQueue = new SynchronousQueue<>();
this.staticObjectList = staticObjectInputList;
this.dynamicObjectList = dynamicObjectInputList;
this.tokenObjectList = tokenObjectInputList;
this.vehicleObjectList = vehicleObjectList;
(new Thread(this,"PreCollHdl")).start();
}
@Override
public void run() {
double[] state = null;
try {
while ((state = inputQueue.take()) != null) {
Graph<IWorldObjectBase<T>> graph = new Graph<IWorldObjectBase<T>>();
List<IWorldObjectBase<T>> visibleObjects = new LinkedList<>();
LinkedList<IWorldDynamicObject<T>> innerDynamicObjects = new LinkedList<IWorldDynamicObject<T>>();
LinkedList<IWorldDynamicObject<T>> outerDynamicObjects = new LinkedList<IWorldDynamicObject<T>>();
LinkedList<IWorldDynamicObject<T>> activeDynamicObjects;
LinkedList<IWorldStaticObject<T>> innerStaticObjects = new LinkedList<IWorldStaticObject<T>>();
LinkedList<IWorldStaticObject<T>> outerStaticObjects = new LinkedList<IWorldStaticObject<T>>();
double xPosition = state[0];// PositionOfCar
populateDynamicObjectsLists(xPosition, state,
innerDynamicObjects, outerDynamicObjects);
populateStaticObjectsLists(xPosition, innerStaticObjects,
outerStaticObjects);
activeDynamicObjects = addDynamicDynamicConnections(
innerDynamicObjects, outerDynamicObjects, graph, state);
addDynamicStaticConnections(activeDynamicObjects,
innerStaticObjects, outerStaticObjects, graph, state);
addVehicleStaticConnections(vehicleObjectList,
innerStaticObjects, graph, state);
addVehcileDynamicConnections(vehicleObjectList,
innerDynamicObjects, graph, state);
// visibleObjects.addAll(innerStaticObjects);
visibleObjects.addAll(innerDynamicObjects);
this.visibleObjects.set(visibleObjects);
this.graph.set(graph);
}
} catch (InterruptedException e) {
// TODO decide what to do now, start the job again?
e.printStackTrace();
} catch (RuntimeException e) {
e.printStackTrace();
System.exit(1);
}
}
public Graph<IWorldObjectBase<T>> getGraph() {
return graph.get();
}
public List<IWorldDynamicObject<T>> getDynamicObjectList() {
return dynamicObjectList;
}
public List<IWorldObjectBase<T>> getVisibleObjectList() {
return visibleObjects.get();
}
public void offer(double[] state) {
inputQueue.offer(state.clone());
}
private double getDistance(Circle circleA, Circle circleB) {
return circleA.A.distance(circleB.A) - circleA.radius - circleB.radius;
}
private LinkedList<IWorldDynamicObject<T>> addDynamicDynamicConnections(
LinkedList<IWorldDynamicObject<T>> innerDynamicObjects,
LinkedList<IWorldDynamicObject<T>> outerDynamicObjects,
Graph<IWorldObjectBase<T>> graph, double[] state) {
innerDynamicObjects = new LinkedList<>(innerDynamicObjects);
LinkedList<IWorldDynamicObject<T>> outList = new LinkedList<IWorldDynamicObject<T>>();
while (!innerDynamicObjects.isEmpty()) {
IWorldDynamicObject<T> objectA = innerDynamicObjects.pop();
outList.add(objectA);
graph.addVertex(objectA);
for (IWorldDynamicObject<T> objectB : innerDynamicObjects) {
double distance = getDistance(objectA.getBoundingCircle(state),
objectB.getBoundingCircle(state));
if (distance < MARGIN)
graph.addDirectedConnection(objectA, objectB);
}
ListIterator<IWorldDynamicObject<T>> iterator = outerDynamicObjects
.listIterator();
while (iterator.hasNext()) {
IWorldDynamicObject<T> objectB = iterator.next();
double distance = getDistance(objectA.getBoundingCircle(state),
objectB.getBoundingCircle(state));
if (distance < MARGIN) {
graph.addDirectedConnection(objectA, objectB);
iterator.remove();
innerDynamicObjects.add(objectB);
}
}
}
return outList;
}
private void populateDynamicObjectsLists(double xPosition, double[] state,
LinkedList<IWorldDynamicObject<T>> innerDynamicObjects,
LinkedList<IWorldDynamicObject<T>> outerDynamicObjects) {
for (IWorldDynamicObject<T> dynamicObject : dynamicObjectList) {
double distance = dynamicObject.getDistanceX(xPosition, state);
//if (dynamicObject.getType() == DynamicTypes.Bridge)
//continue;// A bridge canยดt collide with a road etc
if (distance <= INNER_DISTANCE_MARGIN) {
innerDynamicObjects.add(dynamicObject);
} else if (distance <= OUTER_DISTANCE_MARGIN)
outerDynamicObjects.add(dynamicObject);
}
}
private void populateStaticObjectsLists(double xPosition,
LinkedList<IWorldStaticObject<T>> innerStaticObjects,
LinkedList<IWorldStaticObject<T>> outerStaticObjects) {
for (IWorldStaticObject<T> staticObject : staticObjectList) {
double distance = staticObject.getShortestDistanceX(xPosition);
if (distance <= INNER_DISTANCE_MARGIN) {
innerStaticObjects.add(staticObject);
} else if (distance <= OUTER_DISTANCE_MARGIN)
outerStaticObjects.add(staticObject);
}
}
private void addDynamicStaticConnections(
LinkedList<IWorldDynamicObject<T>> activeDynamicObjects,
LinkedList<IWorldStaticObject<T>> innerStaticObjects,
LinkedList<IWorldStaticObject<T>> outerStaticObjects,
Graph<IWorldObjectBase<T>> graph, double[] state) {
for (IWorldDynamicObject<T> dynamicObject : activeDynamicObjects) {
switch (dynamicObject.getType()) {
case Bridge:
case Pendulum:
case DoublePendulum:
continue;
default:
Circle circle = dynamicObject.getBoundingCircle(state);
for (IWorldStaticObject<T> staticObject : innerStaticObjects) {
double distance = staticObject
.getShortestDistanceX(circle.A.X) - circle.radius;
if (distance < MARGIN)
graph.addDirectedConnection(dynamicObject,
staticObject);
}
for (IWorldStaticObject<T> staticObject : outerStaticObjects) {
double distance = staticObject
.getShortestDistanceX(circle.A.X) - circle.radius;
if (distance < MARGIN)
graph.addDirectedConnection(dynamicObject,
staticObject);
}
}
}
}
private void addVehicleStaticConnections(
List<IVehicleObject<T>> vehicleObjects,
LinkedList<IWorldStaticObject<T>> innerStaticObjects,
Graph<IWorldObjectBase<T>> graph, double[] state) {
for (IVehicleObject<T> vehicleObject : vehicleObjects) {
Circle circle = vehicleObject.getBoundingCircle(state);
for (IWorldStaticObject<T> staticObject : innerStaticObjects) {
double distance = staticObject.getShortestDistanceX(circle.A.X)
- circle.radius;
if (distance < MARGIN)
graph.addDirectedConnection(vehicleObject, staticObject);
}
}
}
private void addVehcileDynamicConnections(
List<IVehicleObject<T>> vehicleObjects,
LinkedList<IWorldDynamicObject<T>> innerDynamicObjects,
Graph<IWorldObjectBase<T>> graph, double[] state) {
for (IVehicleObject<T> vehicleObject : vehicleObjectList) {
Circle circle = vehicleObject.getBoundingCircle(state);
for (IWorldDynamicObject<T> dynamicObject : innerDynamicObjects) {
double distance = getDistance(circle,
dynamicObject.getBoundingCircle(state));
if (distance < MARGIN) {
graph.addDirectedConnection(vehicleObject, dynamicObject);
}
}
}
}
}
| true
|
fb0015e633ba16c112907fcc9bf068e1ba2beff6
|
Java
|
kim-cv/KitchenTimer-Android
|
/app/src/main/java/com/funkyqubits/kitchentimer/ui/timers/TimersFragment.java
|
UTF-8
| 6,900
| 1.828125
| 2
|
[] |
no_license
|
package com.funkyqubits.kitchentimer.ui.timers;
import android.content.DialogInterface;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;
import androidx.navigation.NavController;
import androidx.navigation.Navigation;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.funkyqubits.kitchentimer.Controller.AlarmManagerController;
import com.funkyqubits.kitchentimer.Interfaces.IAlarmTimerObserver;
import com.funkyqubits.kitchentimer.Interfaces.IAlarmTimerUIEventsObserver;
import com.funkyqubits.kitchentimer.Repositories.FileSystemRepository;
import com.funkyqubits.kitchentimer.Repositories.ISharedPreferencesRepository;
import com.funkyqubits.kitchentimer.Repositories.SharedPreferencesRepository;
import com.funkyqubits.kitchentimer.models.AlarmTimer;
import com.funkyqubits.kitchentimer.R;
import com.funkyqubits.kitchentimer.Repositories.IFileSystemRepository;
import com.funkyqubits.kitchentimer.services.AlarmAudioService;
import com.google.android.material.dialog.MaterialAlertDialogBuilder;
import java.util.ArrayList;
public class TimersFragment extends Fragment implements IAlarmTimerUIEventsObserver, IAlarmTimerObserver {
private RecyclerView RecyclerView;
private AlarmTimersAdapter RecyclerViewAdapter;
private TimersViewModel TimersViewModel;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater,
@Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
IFileSystemRepository repository = new FileSystemRepository(requireContext(), getString(R.string.file_timers));
ISharedPreferencesRepository timerOffsets = new SharedPreferencesRepository(getContext());
AlarmManagerController alarmManagerController = new AlarmManagerController(getContext());
TimersViewModelFactory timersViewModelFactory = new TimersViewModelFactory(repository, timerOffsets, alarmManagerController);
TimersViewModel = new ViewModelProvider(this, timersViewModelFactory).get(TimersViewModel.class);
View root = inflater.inflate(R.layout.fragment_timers, container, false);
RecyclerView = root.findViewById(R.id.recyclerview_alarmTimers);
// use this setting to improve performance if you know that changes
// in content do not change the layout size of the RecyclerView
RecyclerView.setHasFixedSize(true);
// use a linear layout manager
RecyclerView.LayoutManager LayoutManager = new LinearLayoutManager(getContext());
RecyclerView.setLayoutManager(LayoutManager);
RecyclerViewAdapter = new AlarmTimersAdapter(this);
return root;
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
// Listen for when timers are ready and then give them to the adapter
TimersViewModel.ObservableAlarmTimers.observe(getViewLifecycleOwner(), new Observer<ArrayList<AlarmTimer>>() {
@Override
public void onChanged(ArrayList<AlarmTimer> alarmTimers) {
RecyclerViewAdapter.SetData(alarmTimers);
RecyclerView.setAdapter(RecyclerViewAdapter);
}
}
);
}
@Override
public void onResume() {
super.onResume();
Log.d("DebugService", "TimersFragment onResume:");
RecyclerViewAdapter.RegisterObserver(this);
TimersViewModel.AddObserverToAlarmTimers(this);
AlarmAudioService.Companion.timersInFocus(requireContext());
}
@Override
public void onPause() {
super.onPause();
Log.d("DebugService", "TimersFragment onPause:");
RecyclerViewAdapter.RemoveObserver(this);
TimersViewModel.RemoveObserverFromAlarmTimers(this);
// Save timers to storage
TimersViewModel.SaveAllTimersToStorage();
}
//#region Timer UI events
@Override
public void OnUIAlarmTimerStart(int alarmTimerID) {
TimersViewModel.StartTimer(alarmTimerID);
}
@Override
public void OnUIAlarmTimerPause(int alarmTimerID) {
TimersViewModel.PauseTimer(alarmTimerID);
}
@Override
public void OnUIAlarmTimerReset(int alarmTimerID) {
TimersViewModel.ResetTimer(alarmTimerID);
}
@Override
public void OnUIAlarmTimerEdit(int alarmTimerID) {
NavController navController = Navigation.findNavController(this.getView());
Bundle bundle = new Bundle();
bundle.putInt(getString(R.string.parameter_timerId), alarmTimerID);
navController.navigate(R.id.navigation_add_timer, bundle);
}
@Override
public void OnUIAlarmTimerDelete(final int alarmTimerID) {
new MaterialAlertDialogBuilder(getActivity())
.setTitle("Are you sure")
.setMessage("You want to remove this timer?")
.setPositiveButton("Yes Remove", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
TimersViewModel.DeleteTimer(alarmTimerID);
}
})
.setNeutralButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
}
})
.show();
}
//#endregion
//#region Events for each alarm timer
@Override
public void OnAlarmTimerStarted(int alarmTimerID) {
Log.d("DebugService", "TimersFragment: OnAlarmTimerStarted");
RecyclerViewAdapter.UpdateItemPosition(alarmTimerID);
}
@Override
public void OnAlarmTimerResumed(int alarmTimerID) {
Log.d("DebugService", "TimersFragment: OnAlarmTimerResumed");
RecyclerViewAdapter.UpdateItemPosition(alarmTimerID);
}
@Override
public void OnAlarmTimerPaused(int alarmTimerID) {
Log.d("DebugService", "TimersFragment: OnAlarmTimerPaused");
RecyclerViewAdapter.UpdateItemPosition(alarmTimerID);
}
@Override
public void OnAlarmTimerReset(int alarmTimerID) {
Log.d("DebugService", "TimersFragment: OnAlarmTimerReset");
AlarmAudioService.Companion.timersInFocus(requireContext());
RecyclerViewAdapter.UpdateItemPosition(alarmTimerID);
}
@Override
public void OnAlarmTimerCompleted(int alarmTimerID) {
Log.d("DebugService", "TimersFragment: OnAlarmTimerCompleted");
}
//#endregion
}
| true
|
3c35f715ff5e72f9b87ee3cdec7aa9f015782239
|
Java
|
KxmischesDomi/CloudNet-v3-Legacy
|
/cloudnet-modules/cloudnet-bridge/src/main/java/de/dytanic/cloudnet/ext/bridge/nukkit/listener/NukkitPlayerListener.java
|
UTF-8
| 3,253
| 1.976563
| 2
|
[
"Apache-2.0"
] |
permissive
|
package de.dytanic.cloudnet.ext.bridge.nukkit.listener;
import cn.nukkit.Player;
import cn.nukkit.Server;
import cn.nukkit.event.EventHandler;
import cn.nukkit.event.EventPriority;
import cn.nukkit.event.Listener;
import cn.nukkit.event.player.PlayerJoinEvent;
import cn.nukkit.event.player.PlayerLoginEvent;
import cn.nukkit.event.player.PlayerQuitEvent;
import cn.nukkit.scheduler.Task;
import de.dytanic.cloudnet.driver.service.ServiceTask;
import de.dytanic.cloudnet.ext.bridge.BridgeConfiguration;
import de.dytanic.cloudnet.ext.bridge.BridgeConfigurationProvider;
import de.dytanic.cloudnet.ext.bridge.BridgeHelper;
import de.dytanic.cloudnet.ext.bridge.OnlyProxyProtection;
import de.dytanic.cloudnet.ext.bridge.nukkit.NukkitCloudNetHelper;
import de.dytanic.cloudnet.wrapper.Wrapper;
public final class NukkitPlayerListener implements Listener {
private final BridgeConfiguration bridgeConfiguration;
private final OnlyProxyProtection onlyProxyProtection;
public NukkitPlayerListener() {
this.bridgeConfiguration = BridgeConfigurationProvider.load();
this.onlyProxyProtection = new OnlyProxyProtection(Server.getInstance().getPropertyBoolean("xbox-auth"));
}
@EventHandler(priority = EventPriority.HIGHEST)
public void handle(PlayerLoginEvent event) {
Player player = event.getPlayer();
if (this.onlyProxyProtection.shouldDisallowPlayer(player.getAddress())) {
event.setCancelled(true);
event.setKickMessage(this.bridgeConfiguration.getMessages().get("server-join-cancel-because-only-proxy").replace('&', 'ยง'));
return;
}
String currentTaskName = Wrapper.getInstance().getServiceId().getTaskName();
ServiceTask serviceTask = Wrapper.getInstance().getServiceTaskProvider().getServiceTask(currentTaskName);
if (serviceTask != null && serviceTask.isMaintenance() && !player.hasPermission("cloudnet.bridge.maintenance")) {
event.setCancelled(true);
event.setKickMessage(this.bridgeConfiguration.getMessages().get("server-join-cancel-because-maintenance").replace('&', 'ยง'));
return;
}
BridgeHelper.sendChannelMessageServerLoginRequest(NukkitCloudNetHelper.createNetworkConnectionInfo(player),
NukkitCloudNetHelper.createNetworkPlayerServerInfo(player, true)
);
}
@EventHandler
public void handle(PlayerJoinEvent event) {
BridgeHelper.sendChannelMessageServerLoginSuccess(NukkitCloudNetHelper.createNetworkConnectionInfo(event.getPlayer()),
NukkitCloudNetHelper.createNetworkPlayerServerInfo(event.getPlayer(), false));
BridgeHelper.updateServiceInfo();
}
@EventHandler
public void handle(PlayerQuitEvent event) {
BridgeHelper.sendChannelMessageServerDisconnect(NukkitCloudNetHelper.createNetworkConnectionInfo(event.getPlayer()),
NukkitCloudNetHelper.createNetworkPlayerServerInfo(event.getPlayer(), false));
event.getPlayer().getServer().getScheduler().scheduleDelayedTask(new Task() {
@Override
public void onRun(int currentTick) {
BridgeHelper.updateServiceInfo();
}
}, 1);
}
}
| true
|
984a1e911b4856404c04fecdd4e11ffd5271a3b1
|
Java
|
davidfeust/Algorithms1
|
/MaxSquare/MaxSquare.java
|
UTF-8
| 1,773
| 3.4375
| 3
|
[] |
no_license
|
public class MaxSquare {
public static int maxSquare(int[][] mat) {
int n = mat.length, m = mat[0].length;
int[][] help = new int[n][m];
for (int i = 0; i < m; i++) help[0][i] = mat[0][i];
for (int i = 0; i < n; i++) help[i][0] = mat[i][0];
int max = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (mat[i][j] == 1) {
help[i][j] = Math.min(Math.min(help[i][j - 1], help[i - 1][j]), help[i - 1][j - 1]) + 1;
}
max = Math.max(max, help[i][j]);
}
// System.out.println(Arrays.toString(help[i]));
}
return max;
}
public static int maxSquare2x2(int[][] mat) {
int n = mat.length, m = mat[0].length;
int[][] help = new int[n][m];
for (int i = 0; i < m; i++) help[0][i] = mat[0][i];
for (int i = 0; i < n; i++) help[i][0] = mat[i][0];
int res = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (mat[i][j] == 1) {
help[i][j] = Math.min(Math.min(help[i][j - 1], help[i - 1][j]), help[i - 1][j - 1]) + 1;
}
if (help[i][j] >= 2) res++;
}
// System.out.println(Arrays.toString(help[i]));
}
return res;
}
public static void main(String[] args) {
int[][] mat = {
{0, 0, 1, 0, 1},
{0, 1, 1, 1, 1},
{1, 1, 1, 1, 0},
{0, 1, 1, 1, 1},
{0, 0, 1, 1, 1},
};
System.out.println("maxSquare(mat) = " + maxSquare(mat));
System.out.println("maxSquare2x2(mat) = " + maxSquare2x2(mat));
}
}
| true
|
e829b3f797b5f9ee34b068570f2ea10e2546799f
|
Java
|
ccw924263/ccwproject
|
/ccw.component/ccw.component.redis/src/main/java/com/ccw/impl/RedisServiceImpl.java
|
UTF-8
| 637
| 2.34375
| 2
|
[] |
no_license
|
package com.ccw.impl;
import com.ccw.IRedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
@Service("redisService")
public class RedisServiceImpl implements IRedisService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public void putToRedis(String key, String value) {
stringRedisTemplate.opsForValue().set(key, value);
}
@Override
public String getByKey(String key) {
return stringRedisTemplate.opsForValue().get(key);
}
}
| true
|
a08c160c3359e69fd31061ded2bf1fc6ff41d5d8
|
Java
|
pandres95/arduino-a-mole
|
/app/src/main/java/me/pandres95/arduinoamole/bluetooth/BluetoothHandler.java
|
UTF-8
| 3,413
| 2.109375
| 2
|
[] |
no_license
|
package me.pandres95.arduinoamole.bluetooth;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import java.io.IOException;
import java.util.UUID;
import me.pandres95.arduinoamole.R;
import me.pandres95.arduinoamole.activities.DeviceListActivity;
public abstract class BluetoothHandler extends AppCompatActivity
implements BluetoothCOM.EventsListener {
private static final int REQUEST_BT_ENABLE = 15;
private static final int REQUEST_BT_PAIR = 16;
private UUID BTMODULEUUID;
private BluetoothCOM bluetoothCOM;
private BluetoothAdapter btAdapter;
private BluetoothSocket btSocket;
private String address;
@Override protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
BTMODULEUUID = UUID.fromString(getString(R.string.bt_uuid));
}
@Override protected void onResume() {
super.onResume();
if(!hasBluetoothAdapter()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_BT_ENABLE);
return;
}
if(address == null) {
Intent getDevicesIntent = new Intent(this, DeviceListActivity.class);
startActivityForResult(getDevicesIntent, REQUEST_BT_PAIR);
return;
}
BluetoothDevice device = btAdapter.getRemoteDevice(address);
try {
btSocket = createBluetoothSocket(device);
} catch (IOException e) { onBluetoothException(e); }
try {
bluetoothCOM = new BluetoothCOM(this, btSocket);
btSocket.connect();
bluetoothCOM.initialize();
} catch (IOException connectException) {
onBluetoothException(connectException);
try {
btSocket.close();
bluetoothCOM.close();
} catch (IOException closeException) {
onBluetoothException(closeException);
}
}
}
@Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode) {
case REQUEST_BT_ENABLE: {
onResume();
return;
}
case REQUEST_BT_PAIR: {
if(data.hasExtra(DeviceListActivity.EXTRA_DEVICE_ADDRESS))
address = data.getStringExtra(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
return;
}
}
}
@Override protected void onPause() {
super.onPause();
if(btSocket != null) try {
btSocket.close();
bluetoothCOM.close();
} catch (IOException ex) { finish(); }
}
public BluetoothCOM getBluetoothCOM() {
return bluetoothCOM;
}
boolean hasBluetoothAdapter() {
return (btAdapter = BluetoothAdapter.getDefaultAdapter()) != null && btAdapter.isEnabled();
}
BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
return device.createRfcommSocketToServiceRecord(BTMODULEUUID);
}
}
| true
|
f7e9a07b8832b036180368326a444a808bcb70a1
|
Java
|
goodev/liudongbaoproject
|
/com.mymoney/src/vv.java
|
UTF-8
| 1,175
| 2.28125
| 2
|
[] |
no_license
|
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
public class vv
implements Serializable
{
private String a;
private List b;
private List c;
public vv(String paramString)
{
ArrayList localArrayList1 = new ArrayList();
this.b = localArrayList1;
ArrayList localArrayList2 = new ArrayList();
this.c = localArrayList2;
this.a = paramString;
}
public double a(int paramInt)
{
return ((Double)this.c.get(paramInt)).doubleValue();
}
public int a()
{
return this.c.size();
}
public void a(String paramString, double paramDouble)
{
boolean bool1 = this.b.add(paramString);
List localList = this.c;
Double localDouble = Double.valueOf(paramDouble);
boolean bool2 = localList.add(localDouble);
}
public String b(int paramInt)
{
String str1 = (String)this.b.get(paramInt);
if (str1 == null);
for (String str2 = ""; ; str2 = str1)
return str2;
}
}
/* Location: F:\soft\android\soft\dex2jar-0.0.7.10-SNAPSHOT\classes.dex.dex2jar.jar
* Qualified Name: vv
* JD-Core Version: 0.6.0
*/
| true
|
f37683824e2b173103e6ed2e18c145ae25ecaed3
|
Java
|
choijinsil/SeatLayout
|
/SeatLayout/src/main/java/com/myway/seat/api/service/SaveService.java
|
UTF-8
| 643
| 1.992188
| 2
|
[
"MIT"
] |
permissive
|
package com.myway.seat.api.service;
import java.util.List;
import com.myway.seat.api.model.entity.Save;
/**
* ํด๋์ค์ ๋ํ ์ค๋ช
์ ์ฌ๊ธฐ์ ์ด๋ค.
*
* @author js
* @since 2018. 12. 2.
* @version 1.0
* @see <pre>
* == ๊ฐ์ ์ด๋ ฅ(Modification Information) ==
*
* ์์ ์ผ ์์ ์ ์์ ๋ด์ฉ
* ---------------------------------------------------------------------------------
* 2018. 12. 2. js ์ต์ด์์ฑ
*
* </pre>
*/
public interface SaveService {
List<Save> findAll();
Save findSaveById(String itemId);
List<Save> findSaveByPrice(String itemPrice);
}
| true
|
2172481b65b364e3a47ada3634412eb19cc485a2
|
Java
|
chaimabr/TopicViewerWeb
|
/src/com/twitter/HashtagElement.java
|
UTF-8
| 480
| 2.1875
| 2
|
[] |
no_license
|
/* Generated by JavaFromJSON */
/*http://javafromjson.dashingrocket.com*/
package com.twitter;
public class HashtagElement {
private java.lang.Integer[] indices;
public void setIndices(java.lang.Integer[] indices) {
this.indices = indices;
}
public java.lang.Integer[] getIndices() {
return indices;
}
private java.lang.String text;
public void setText(java.lang.String text) {
this.text = text;
}
public java.lang.String getText() {
return text;
}
}
| true
|
c49c1eacd0cf118c01fb2868cead0de2a5ae530e
|
Java
|
joaoo-vittor/estudo-java
|
/DesktopComSwing/Calculadora/cursojava/calc/visao/Display.java
|
UTF-8
| 743
| 2.984375
| 3
|
[] |
no_license
|
package cursojava.calc.visao;
import java.awt.*;
import javax.swing.JLabel;
import javax.swing.JPanel;
import cursojava.calc.modelo.Memoria;
import cursojava.calc.modelo.MemoriaObservador;
public class Display extends JPanel implements MemoriaObservador {
private final JLabel label;
public Display() {
Memoria.getInstacia().adicionarObservador(this);
setBackground(new Color(46, 49, 50));
label = new JLabel(Memoria.getInstacia().getTextoAtual());
label.setForeground(Color.WHITE);
label.setFont(new Font("courier", Font.PLAIN, 30));
setLayout(new FlowLayout(FlowLayout.RIGHT, 10, 25));
add(label);
}
@Override
public void valorAlterado(String novoValor) {
label.setText(novoValor);
}
}
| true
|
2d349501ac0e7101aa8cbe997bd9aa28296932a6
|
Java
|
CodecoolMSC2017/ip-apache
|
/src/main/java/com/codecool/lms/model/GradeStatisticsChart.java
|
UTF-8
| 1,742
| 2.78125
| 3
|
[] |
no_license
|
package com.codecool.lms.model;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import java.awt.*;
import java.util.List;
public class GradeStatisticsChart {
public GradeStatisticsChart() {}
public DefaultCategoryDataset createDataset(User currentUser, List<Assignment> currentUserAssignments) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for (Assignment assignment : currentUserAssignments) {
dataset.setValue(calculateGradePercentage((double)assignment.getGrade(),
(double)assignment.getMaxScore()),
assignment.getTitle(),
assignment.getDate());
}
return dataset;
}
public static double calculateGradePercentage(double grade, double maxScore) {
return (grade / maxScore) * 100;
}
public JFreeChart createChart(DefaultCategoryDataset dataset) {
JFreeChart chart = ChartFactory.createBarChart(
"Grade Statistics", // chart title
"Date", // domain axis label
"Grade percentage (%)", dataset,
PlotOrientation.VERTICAL, // orientation
true, // include legend
true, // tooltips?
false // URLs?
);
chart.setBackgroundPaint(Color.white);
CategoryPlot plot = chart.getCategoryPlot();
plot.getRangeAxis().setLowerBound(0);
plot.getRangeAxis().setUpperBound(100);
return chart;
}
}
| true
|
c61733202ab3d75346a212465526f24d2f7b27fc
|
Java
|
anterostecnologia/anterosintegracaobancaria
|
/src/main/java/br/com/anteros/integracao/bancaria/banco/Pessoa.java
|
UTF-8
| 5,933
| 2.203125
| 2
|
[] |
no_license
|
/*******************************************************************************
* Copyright 2016 Anteros Tecnologia
*
* 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 br.com.anteros.integracao.bancaria.banco;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import br.com.anteros.automacao.bancaria.comum.pessoa.contato.NumeroDeTelefone;
import br.com.anteros.automacao.bancaria.comum.pessoa.endereco.Endereco;
import br.com.anteros.automacao.bancaria.comum.pessoa.id.cprf.AbstractCPRF;
import br.com.anteros.automacao.bancaria.comum.pessoa.id.cprf.CPRF;
import br.com.anteros.core.utils.ObjectUtils;
import br.com.anteros.integracao.bancaria.banco.layout.ContaBancaria;
/**
*
* <p>
* Representa uma pessoa no negรณcio de boletos bancรกrios.
* Ela pode assumir trรชs papรฉis diferentes:
* <ul>
* <li>Cedente</li>
* <li>Sacador</li>
* <li>Sacador Avalista</li>
* </ul>
* </p>
*
*/
public class Pessoa implements br.com.anteros.automacao.bancaria.comum.pessoa.Pessoa {
private String nome;
/**
* @see CPRF
*/
private CPRF cprf;
/**
* @see NumeroDeTelefone
*/
private Collection<NumeroDeTelefone> telefones;
/**
* @see Endereco
*/
private Collection<Endereco> enderecos;
/**
* @see ContaBancaria
*/
private Collection<ContaBancaria> contasBancarias;
public Pessoa() {}
public Pessoa(String nome) {
this.nome = nome;
}
public Pessoa(String nome, String cadastroDePessoa) {
this.nome = nome;
this.cprf = AbstractCPRF.create(cadastroDePessoa);
}
public Pessoa(String nome, CPRF cadastroDePessoa) {
this.nome = nome;
this.cprf = cadastroDePessoa;
}
/**
* @see ContaBancaria
*/
public void addContaBancaria(ContaBancaria contaBancaria) {
if(ObjectUtils.isNull(contasBancarias)){
contasBancarias = new ArrayList<ContaBancaria>();
}
contasBancarias.add(contaBancaria);
}
/**
* Verifica se esta pessoa tem alguma conta bancรกria.
*
* @see ContaBancaria
*/
public boolean hasContaBancaria(){
return getContasBancarias() !=null && getContasBancarias().size()>0;
}
/**
* @see Endereco
*/
public void addEndereco(Endereco endereco) {
if(ObjectUtils.isNull(enderecos)){
enderecos = new ArrayList<Endereco>();
}
enderecos.add(endereco);
}
/**
* @see NumeroDeTelefone
*/
public void addTelefone(NumeroDeTelefone telefone) {
if(ObjectUtils.isNull(telefones)){
telefones = new ArrayList<NumeroDeTelefone>();
}
telefones.add(telefone);
}
/**
* @see CPRF
*/
public CPRF getCPRF() {
return cprf;
}
/**
* Retorna o resultado de uma chamada a {@code iterator.next()} de
* {@linkplain #getContasBancarias()}, caso exista alguma conta, ou null, caso
* nรฃo exista {@linkplain #contasBancarias}.
*
* @return Chamada a {@code iterator.next()}, caso exista algum endereรงo ou
* null.
*/
public ContaBancaria getNextContaBancaria(){
if(hasContaBancaria()){
return getContasBancarias().iterator().next();
}
return null;
}
/**
* @see ContaBancaria
* @see Collection
*/
public Collection<ContaBancaria> getContasBancarias() {
return contasBancarias;
}
/**
* Retorna o resultado de uma chamada a {@code iterator.next()} de
* {@linkplain #getEnderecos()}, caso exista algum endereรงo, ou null, caso
* nรฃo exista {@linkplain #enderecos}.
*
* @return Chamada a {@code iterator.next()}, caso exista algum endereรงo ou
* null.
*/
public Endereco getNextEndereco(){
if(getEnderecos()!=null && getEnderecos().size()>0){
return getEnderecos().iterator().next();
}
return null;
}
/**
* @see Endereco
* @see Collection
*/
public Collection<Endereco> getEnderecos() {
return Collections.unmodifiableCollection(enderecos);
}
public String getNome() {
return nome;
}
/**
* Retorna o resultado de uma chamada a {@code iterator.next()} de
* {@linkplain #getTelefones()}, caso exista algum telefone, ou null, caso
* nรฃo exista {@linkplain #telefones}.
*
* @return Chamada a {@code iterator.next()}, caso exista algum endereรงo ou
* null.
*/
public NumeroDeTelefone getNextTelefone(){
if(getTelefones() !=null && getTelefones().size()>0){
return getTelefones().iterator().next();
}
return null;
}
/**
* @see NumeroDeTelefone
* @see Collection
*/
public Collection<NumeroDeTelefone> getTelefones() {
return telefones;
}
/**
* @see CPRF
*/
public void setCPRF(CPRF cprf) {
this.cprf = cprf;
}
public void setNome(String nome) {
this.nome = nome;
}
/**
* Verifica se esta pessoa รฉ uma instรขncia de <code>PessoaFisica</code>.
*
* @see br.com.anteros.automacao.bancaria.comum.pessoa.Pessoa#isFisica()
*/
public boolean isFisica() {
return (this instanceof PessoaFisica);
}
/**
* Verifica se esta pessoa รฉ uma instรขncia de <code>PessoaJuridica</code>.
*
* @see br.com.anteros.automacao.bancaria.comum.pessoa.Pessoa#isJuridica()
*/
public boolean isJuridica() {
return (this instanceof PessoaJuridica);
}
@Override
public String toString() {
return "Pessoa [nome=" + nome + ", cprf=" + cprf + ", telefones=" + telefones + ", enderecos=" + enderecos
+ ", contasBancarias=" + contasBancarias + "]";
}
}
| true
|
2efd00b64479d7106f07fe9ffa9e6c28b0c840a5
|
Java
|
lxchinesszz/webspider
|
/src/test/java/org/spider/boot/weibo/WbUser.java
|
UTF-8
| 272
| 1.5625
| 2
|
[] |
no_license
|
package org.spider.boot.weibo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* @author liuxin
* @version Id: WbUser.java, v 0.1 2018/7/30 ไธๅ2:07
*/
@Data
@AllArgsConstructor
public class WbUser {
private String userName;
private String src;
}
| true
|
909b950d064dc5b6729c6525d028f1bfb1934848
|
Java
|
kchettiyar/java_practice
|
/OppsCon/src/main/java/CheckInstanceOf/shortcircutOpes.java
|
UTF-8
| 622
| 3.453125
| 3
|
[] |
no_license
|
package CheckInstanceOf;
public class shortcircutOpes {
public static void main(String[] args) {
if (m1() || m2()) {
System.out.println("condition satisfied");
} else
System.out.println("condition not satisfied");
System.out.println((m3() & m4()) + " num condition satisfied");
}
public static boolean m1() {
System.out.println("m1 method");
return true;
}
public static boolean m2() {
System.out.println("m2 method");
return true;
}
public static int m3() {
System.out.println("m3 method");
return 4;
}
public static int m4() {
System.out.println("m4 method");
return 5;
}
}
| true
|
883c99b7d40ea7d71c852a86cb5271a3f3f3ee4a
|
Java
|
hcysct/ImageEditor
|
/app/src/main/java/com/createchance/imageeditordemo/model/SimpleModel.java
|
UTF-8
| 664
| 2.546875
| 3
|
[
"Apache-2.0"
] |
permissive
|
package com.createchance.imageeditordemo.model;
import android.graphics.Bitmap;
/**
* ${DESC}
*
* @author createchance
* @date 2018/11/3
*/
public class SimpleModel {
private static SimpleModel sInstance;
private Bitmap mImage;
private SimpleModel() {
}
public static synchronized SimpleModel getInstance() {
if (sInstance == null) {
sInstance = new SimpleModel();
}
return sInstance;
}
public void putImage(Bitmap image) {
if (mImage != null) {
mImage.recycle();
}
mImage = image;
}
public Bitmap getImage() {
return mImage;
}
}
| true
|
7383a5872f9b96ec0bd3ef749cb7b405fbb4d221
|
Java
|
gsool/mqtt-broker
|
/broker-core/src/main/java/com/yao/broker/core/handler/TcpIdleTimeoutHandler.java
|
UTF-8
| 1,193
| 2.265625
| 2
|
[] |
no_license
|
package com.yao.broker.core.handler;
import com.yao.broker.core.utils.NettyUtils;
import io.netty.channel.ChannelDuplexHandler;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import lombok.extern.slf4j.Slf4j;
import static io.netty.channel.ChannelFutureListener.CLOSE_ON_FAILURE;
/**
* @Description: TCPๅฟ่ทณๅๅบ่ถ
ๆถๅค็
* @Author yao.zou
* @Date 2019/8/26 0026
* @Version V1.0
**/
@Slf4j
@ChannelHandler.Sharable
public class TcpIdleTimeoutHandler extends ChannelDuplexHandler {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent){
IdleState e = ((IdleStateEvent) evt).state();
if (e == IdleState.READER_IDLE) {
log.info("Firing channel inactive event. MqttClientId = {}.", NettyUtils.clientID(ctx.channel()));
ctx.fireChannelInactive();
ctx.close().addListener(CLOSE_ON_FAILURE);
}
}else {
super.userEventTriggered(ctx, evt);
}
}
}
| true
|
b4766988d8530a159e78aa7dd79ae9dc92f199a9
|
Java
|
drerek/microservice_application
|
/third-service/src/main/java/com/kpi/project/third/service/service/JwtService.java
|
UTF-8
| 2,774
| 2.296875
| 2
|
[] |
no_license
|
package com.kpi.project.third.service.service;
import com.kpi.project.third.service.entity.User;
import com.kpi.project.third.service.security.jwt.SecretKeyProvider;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.Date;
import static java.time.ZoneOffset.UTC;
@PropertySource("classpath:image.properties")
@PropertySource("classpath:jwt.properties")
@Component
public class JwtService {
private static Logger log = LoggerFactory.getLogger(JwtService.class);
private final static String JWT_SUBJECT = "jwt.subject";
private final static String JWT_ISSUER = "jwt.issuer";
private final static String JWT_LOGIN = "jwt.login";
private final static String JWT_EMAIL = "jwt.email";
private final static String JWT_ID = "jwt.id";
@Autowired
private Environment env;
private final SecretKeyProvider secretKeyProvider;
@Autowired
public JwtService(SecretKeyProvider secretKeyProvider) {
this.secretKeyProvider = secretKeyProvider;
}
public User verify(String token) {
log.debug("Trying to get secret key form SecretKeyProvider");
byte[] secretKey = secretKeyProvider.getKey();
log.debug("Trying to parse email from token '{}'", token);
Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
String login = claims.getBody().get(env.getProperty(JWT_LOGIN)).toString();
log.debug("Login '{}' was parsed successfully", login);
log.debug("Login '{}' was parsed successfully", login);
User user = new User();
user.setLogin(login);
return user;
}
public String tokenFor(User user) {
log.debug("Trying to get secret key form SecretKeyProvider");
byte[] secretKey = secretKeyProvider.getKey();
log.debug("Trying to build a token for user '{}'", user);
Date expiration = Date.from(LocalDateTime.now(UTC).plusDays(365).toInstant(UTC));
return Jwts.builder()
.setSubject(env.getProperty(JWT_SUBJECT))
.setExpiration(expiration)
.setIssuer(env.getProperty(JWT_ISSUER))
.claim(env.getProperty(JWT_LOGIN), user.getLogin())
.claim(env.getProperty(JWT_ID), user.getId())
.signWith(SignatureAlgorithm.HS512, secretKey)
.compact();
}
}
| true
|
bcd316918444904d4ed7ba986153aa66d9b7e0e8
|
Java
|
shao139772/springboot2WithSecurity
|
/src/main/java/com/ubisys/drone/config/exception/DroneException.java
|
UTF-8
| 274
| 2.171875
| 2
|
[] |
no_license
|
package com.ubisys.drone.config.exception;
import lombok.Data;
/**
* ่ชๅฎไนๅผๅธธ็ฑป
*/
@Data
public class DroneException extends RuntimeException {
private String msg;
public DroneException(String msg) {
super(msg);
this.msg = msg;
}
}
| true
|
83f7d551fbe62f44978548b109f05bbad9012fad
|
Java
|
hutomadotAI/web-api
|
/service/core-service/src/main/java/com/hutoma/api/connectors/aiservices/ControllerConnector.java
|
UTF-8
| 13,382
| 1.859375
| 2
|
[
"Apache-2.0"
] |
permissive
|
package com.hutoma.api.connectors.aiservices;
import com.google.common.collect.ImmutableMap;
import com.hutoma.api.common.Config;
import com.hutoma.api.common.JsonSerializer;
import com.hutoma.api.common.SupportedLanguage;
import com.hutoma.api.common.Tools;
import com.hutoma.api.connectors.*;
import com.hutoma.api.connectors.chat.ChatBackendConnector;
import com.hutoma.api.containers.*;
import com.hutoma.api.containers.sub.AiIdentity;
import com.hutoma.api.containers.sub.ServerEndpointRequestMulti;
import com.hutoma.api.logging.ILogger;
import com.hutoma.api.logging.LogMap;
import org.glassfish.jersey.client.ClientProperties;
import org.glassfish.jersey.client.JerseyClient;
import org.glassfish.jersey.client.JerseyWebTarget;
import javax.inject.Inject;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.core.Response;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* Connector for the AI Backend Management Controller.
*/
public abstract class ControllerConnector {
static final String LOGFROM = "controllerconnector";
private static final String PARAM_SERVER_TYPE = "serverType";
private static final String PARAM_SERVER_LANGUAGE = "serverLanguage";
private static final String PARAM_SERVER_VERSION = "serverVersion";
private static final int CONNECTION_TIMEOUT = 1000; // 1s
private static final int READ_TIMEOUT = 1000; // 1s
private static final String CONTROLLER_ENDPOINT = "controller";
private final Config config;
private final JerseyClient jerseyClient;
final ILogger logger;
private final Tools tools;
@Inject
public ControllerConnector(final Config config,
final JerseyClient jerseyClient,
final ILogger logger,
final Tools tools) {
this.config = config;
this.jerseyClient = jerseyClient;
this.logger = logger;
this.tools = tools;
}
public abstract BackendServerType getServerType();
void kickQueueProcessor(final SupportedLanguage language, final String serverVersion) {
this.kickQueue(buildServiceIdentityFromParams(language, serverVersion));
}
/**
* Gets from the controller a training backend endpoint for a given AI.
*
* @param aiIdentity the AIID
* @param serializer the json serialiser
* @return the endpoint information
* @throws NoServerAvailableException if there are no servers available to process this request
*/
IServerEndpoint getBackendTrainingEndpoint(final AiIdentity aiIdentity, final JsonSerializer serializer)
throws NoServerAvailableException {
return getBackendTrainingEndpoint(aiIdentity, this.getServerType(), serializer);
}
/**
* Gets from the controller a training backend endpoint for a given AI.
*
* @param aiIdentity the AIID
* @param serverType the server type
* @param serializer the json serialiser
* @return the endpoint information
* @throws NoServerAvailableException if there are no servers available to process this request
*/
IServerEndpoint getBackendTrainingEndpoint(final AiIdentity aiIdentity,
final BackendServerType serverType,
final JsonSerializer serializer)
throws NoServerAvailableException {
if (aiIdentity == null || aiIdentity.getAiid() == null) {
throw new IllegalArgumentException("aiIdentity");
}
ServiceIdentity serviceIdentity = buildServiceIdentityFromAi(aiIdentity);
LogMap logMap = LogMap.map("AIID", aiIdentity.getAiid().toString())
.put("RequestFor", RequestFor.Training.toString())
.put("ServerType", serverType.value())
.put("Language", aiIdentity.getLanguage())
.put("EngineVersion", aiIdentity.getServerVersion());
final long startTimestamp = this.tools.getTimestamp();
try (Response response = getRequest(String.format("/%s/training", aiIdentity.getAiid().toString()),
getMapOfServiceIdentity(serviceIdentity))
.get()) {
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
response.bufferEntity();
ApiServerEndpoint result = (ApiServerEndpoint) serializer.deserialize(
(InputStream) response.getEntity(), ApiServerEndpoint.class);
this.logger.logPerf(LOGFROM, "GetBackendEndpoint", logMap
.put("Duration", this.tools.getTimestamp() - startTimestamp));
return result.asServerEndpoint();
}
throw new NoServerAvailableException(String.format("No server available for %s for %s on %s",
aiIdentity.getAiid().toString(), RequestFor.Training.toString(), serviceIdentity.toString()));
} catch (NoServerAvailableException ex) {
// rethrow
throw ex;
} catch (Exception ex) {
this.logger.logException(LOGFROM, ex, logMap);
}
return null;
}
/***
* For each bot in a list, get a chat endpoint and a valid hashcode for the instance
* @param multiRequest
* @return the map of AIIDs and respective responses from the possible endpoints
* @throws ChatBackendConnector.AiControllerException
*/
public Map<UUID, ApiServerEndpointMulti.ServerEndpointResponse> getBackendChatEndpointMulti(
final ServerEndpointRequestMulti multiRequest,
final JsonSerializer serializer)
throws ChatBackendConnector.AiControllerException {
if (multiRequest == null) {
throw new IllegalArgumentException("multiRequest");
}
LogMap logMap = LogMap.map("RequestFor", RequestFor.Chat.toString())
.put("ServerType", this.getServerType().value());
// for now just assume the language and server version are all the same
SupportedLanguage language = multiRequest.getEndpointRequests().get(0).getLanguage();
String serverVersion = multiRequest.getEndpointRequests().get(0).getServerVersion();
final long startTimestamp = this.tools.getTimestamp();
try (Response response = getRequest("/chatEndpoints",
getMapOfServiceIdentity(buildServiceIdentityFromParams(language, serverVersion)))
.post(Entity.json(serializer.serialize(multiRequest)))) {
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
response.bufferEntity();
ApiServerEndpointMulti result = (ApiServerEndpointMulti) serializer.deserialize(
(InputStream) response.getEntity(), ApiServerEndpointMulti.class);
this.logger.logPerf(LOGFROM, "GetServerEndpointMulti", logMap
.put("Duration", this.tools.getTimestamp() - startTimestamp));
return result.getEndpointMap();
}
throw new ChatBackendConnector.AiControllerException(
String.format("getBackendChatEndpointMulti returned Error %d", response.getStatus()));
} catch (ChatBackendConnector.AiControllerException ce) {
throw ce;
} catch (Exception ex) {
throw new ChatBackendConnector.AiControllerException(ex);
}
}
/**
* Gets a map of the verified endpoints from all registered backends.
*
* @return the map
*/
public Map<String, ServerTrackerInfo> getEndpointsForBroadcast(final JsonSerializer serializer) {
final long startTimestamp = this.tools.getTimestamp();
try (Response response = getRequest("/endpoints", Collections.emptyMap()).get()) {
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
response.bufferEntity();
ApiServerTrackerInfoMap result = (ApiServerTrackerInfoMap) serializer.deserialize(
(InputStream) response.getEntity(), ApiServerTrackerInfoMap.class);
this.logger.logPerf(LOGFROM, "GetEndpointsForBroadcast",
LogMap.map("Duration", this.tools.getTimestamp() - startTimestamp));
return result.getMap();
}
} catch (Exception ex) {
this.logger.logException(LOGFROM, ex);
}
return new HashMap<>();
}
Map<String, ServerTrackerInfo> getVerifiedEndpointMap(final SupportedLanguage supportedLanguage,
final String version,
final JsonSerializer serializer) {
return getVerifiedEndpointMap(buildServiceIdentityFromParams(supportedLanguage, version), serializer);
}
/**
* Gets a map of the verified endpoints for a given backend server type.
*
* @param serviceIdentity the backend server type
* @return the map
*/
private Map<String, ServerTrackerInfo> getVerifiedEndpointMap(final ServiceIdentity serviceIdentity,
final JsonSerializer serializer) {
LogMap logMap = LogMap.map("ServerType", serviceIdentity.getServerType().value())
.put("Language", serviceIdentity.getLanguage().toString())
.put("EngineVersion", serviceIdentity.getVersion());
final long startTimestamp = this.tools.getTimestamp();
try (Response response = getRequest("/endpointMap", getMapOfServiceIdentity(serviceIdentity))
.get()) {
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
response.bufferEntity();
ApiServerTrackerInfoMap result = (ApiServerTrackerInfoMap) serializer.deserialize(
(InputStream) response.getEntity(), ApiServerTrackerInfoMap.class);
this.logger.logPerf(LOGFROM, "GetVerifiedEndpointMap",
logMap.put("Duration", this.tools.getTimestamp() - startTimestamp));
return result.getMap();
}
} catch (Exception ex) {
this.logger.logException(LOGFROM, ex, logMap);
}
return new HashMap<>();
}
private Invocation.Builder getRequest(final String path,
final Map<String, String> queryParams,
final int connectionTimeout,
final int readTimeout) {
JerseyWebTarget target = this.jerseyClient.target(this.config.getControllerEndpoint())
.path(CONTROLLER_ENDPOINT);
if (path != null && !path.isEmpty()) {
target = target.path(path);
}
if (queryParams != null && !queryParams.isEmpty()) {
for (Map.Entry<String, String> entry : queryParams.entrySet()) {
target = target.queryParam(entry.getKey(), entry.getValue());
}
}
Invocation.Builder request = target.request();
request.property(ClientProperties.CONNECT_TIMEOUT, connectionTimeout);
request.property(ClientProperties.READ_TIMEOUT, readTimeout);
return request;
}
Invocation.Builder getRequest(final String path, final Map<String, String> queryParams) {
return this.getRequest(path, queryParams, CONNECTION_TIMEOUT, READ_TIMEOUT);
}
private void kickQueue(final ServiceIdentity serviceIdentity) {
LogMap logMap = LogMap.map("ServerType", serviceIdentity.getServerType().value())
.put("Language", serviceIdentity.getLanguage().toString())
.put("EngineVersion", serviceIdentity.getVersion());
final long startTimestamp = this.tools.getTimestamp();
try (Response response = getRequest("/queue", getMapOfServiceIdentity(serviceIdentity))
.post(Entity.text(""))) {
if (response.getStatus() == HttpURLConnection.HTTP_OK) {
response.bufferEntity();
this.logger.logPerf(LOGFROM, "KickQueue",
logMap.put("Duration", this.tools.getTimestamp() - startTimestamp));
}
} catch (Exception ex) {
this.logger.logException(LOGFROM, ex, logMap);
}
}
private static Map<String, String> getMapOfServiceIdentity(final ServiceIdentity serviceIdentity) {
return ImmutableMap.of(
PARAM_SERVER_TYPE, serviceIdentity.getServerType().value(),
PARAM_SERVER_LANGUAGE, serviceIdentity.getLanguage().name(),
PARAM_SERVER_VERSION, serviceIdentity.getVersion());
}
private ServiceIdentity buildServiceIdentityFromAi(final AiIdentity aiIdentity) {
return buildServiceIdentityFromParams(aiIdentity.getLanguage(), aiIdentity.getServerVersion());
}
private ServiceIdentity buildServiceIdentityFromParams(final SupportedLanguage language,
final String serverVersion) {
return new ServiceIdentity(this.getServerType(), language, serverVersion);
}
}
| true
|
093dadcd28264ac258e7c1c0b206e573733eada0
|
Java
|
punitmantree/LcoAndroidProjects
|
/FactorialApp/app/src/main/java/com/example/punnit/factorialapp/MainActivity.java
|
UTF-8
| 960
| 2.328125
| 2
|
[] |
no_license
|
package com.example.punnit.factorialapp;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
public class MainActivity extends AppCompatActivity {
Button b;
EditText ed;
TextView t;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
b=(Button)findViewById(R.id.bottom);
ed=(EditText)findViewById(R.id.editText);
t=(TextView)findViewById(R.id.textView);
}
public void fact(View v)
{
String s=ed.getText().toString();
int n=Integer.parseInt(s);
int temp=1;
for (int i=1;i<=n;i++)
{
temp=temp*i;
}
String res=String.valueOf(temp);
t.setText(res);
ed.setText(null);
}
}
| true
|
6d3cbcdb72b79a78d4f551a0e332dd0d4a33f9d3
|
Java
|
wozhaosini/ucloud
|
/ucloud-all/ucloud-usermanage/src/main/java/org/dlut/ucloud/usermanage/service/impl/UserManageService.java
|
UTF-8
| 2,874
| 2.15625
| 2
|
[] |
no_license
|
/*
* Copyright 2014 etao.com All right reserved. This software is the
* confidential and proprietary information of etao.com ("Confidential
* Information"). You shall not disclose such Confidential Information and shall
* use it only in accordance with the terms of the license agreement you entered
* into with etao.com .
*/
package org.dlut.ucloud.usermanage.service.impl;
import javax.annotation.Resource;
import org.dlut.ucloud.common.UCloudResult;
import org.dlut.ucloud.usermanage.common.RoleEnum;
import org.dlut.ucloud.usermanage.convent.UserConvent;
import org.dlut.ucloud.usermanage.dal.dataobject.UserDO;
import org.dlut.ucloud.usermanage.dao.UserManageDAO;
import org.dlut.ucloud.usermanage.domain.UserDTO;
import org.dlut.ucloud.usermanage.service.IUserManageService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
/**
* ็ฑปUserManageService.java็ๅฎ็ฐๆ่ฟฐ๏ผTODO ็ฑปๅฎ็ฐๆ่ฟฐ
*
* @author luojie 2014ๅนด9ๆ22ๆฅ ไธๅ10:46:29
*/
@Service("userManageService")
public class UserManageService implements IUserManageService {
private static Logger log = LoggerFactory.getLogger(UserManageService.class);
@Resource
private UserManageDAO userManageDAO;
@Override
public UCloudResult<UserDTO> getUserByAccount(String account) {
UserDO userDO = userManageDAO.getUserByAccount(account);
UserDTO userDTO = UserConvent.conventToUserDTO(userDO);
return UCloudResult.successResult(userDTO);
// UserDTO userDTO = new UserDTO();
// userDTO.setAccount("200992288");
// userDTO.setUserName("luojie");
// userDTO.setRole(RoleEnum.STUDENT);
// return UCloudResult.successResult(userDTO);
}
@Override
public UCloudResult<UserDTO> verifyAndGetUser(String account, String password, RoleEnum roleEnum) {
if (account == null || password == null || roleEnum == null) {
return UCloudResult.successResult(null);
}
UserDO userDO = userManageDAO.getUserByAccount(account);
if (userDO == null) {
// ่ดฆๅทไธๅญๅจ
log.info("็จๆท่ดฆๅท" + account + " ไธๅญๅจ");
return UCloudResult.successResult(null);
}
if (!userDO.getPassword().equals(password)) {
// ๅฏ็ ้่ฏฏ
log.info("่ดฆๅท" + account + "็ๅฏ็ ้่ฏฏ");
return UCloudResult.successResult(null);
}
if (userDO.getRole() != roleEnum.getStatus()) {
// ็จๆทไธๅฑไบๆญค่ง่ฒ
log.info("่ดฆๅท" + account + "ไธๅฑไบ่ง่ฒ" + roleEnum.getDesc());
return UCloudResult.successResult(null);
}
UserDTO userDTO = UserConvent.conventToUserDTO(userDO);
return UCloudResult.successResult(userDTO);
}
}
| true
|
42cebec32099355e48c284be72bb796ad7ecd1e1
|
Java
|
18965050/oasis
|
/support/archetype/src/main/resources/archetype-resources/src/main/java/authc/DemoRealm.java
|
UTF-8
| 1,791
| 2.1875
| 2
|
[] |
no_license
|
#set($symbol_pound='#')#set($symbol_dollar='$')#set($symbol_escape='\')package ${package}.authc;
import ${package}.authc.entity.AccInfo;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import ${package}.authc.entity.KeyUsernamePwdToken;import ${package}.web.service.AuthService;
/**
* DemoRealm <br/>
* ็คบไพ่ฎค่ฏๆๆ
*
* @version 1.0.0 <br/>
* ๅๅปบๆถ้ด๏ผ2014ๅนด6ๆ25ๆฅ ไธๅ7:55:36
* @author lcg
*/
public class DemoRealm extends AuthorizingRealm {
@Autowired
private AuthService authService;
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
// ๆฒกๆๆ้
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
KeyUsernamePwdToken loginToken = (KeyUsernamePwdToken) token;
return authService.getAuthInfo(loginToken, getName());
}
/**
* @return the authService
*/
public AuthService getAuthService() {
return authService;
}
/**
* @param authService the authService to set
*/
public void setAuthService(AuthService authService) {
this.authService = authService;
}
@Override
protected Object getAuthorizationCacheKey(PrincipalCollection principals) {
AccInfo accInfo = (AccInfo) principals.getPrimaryPrincipal();
return accInfo.getId().toString();
}
}
| true
|
7e54de9eba01a002e64cefb03553b6b909a5f45f
|
Java
|
dys1715/CLMS
|
/app/src/main/java/dys/clms/bean/Config.java
|
UTF-8
| 681
| 2.328125
| 2
|
[] |
no_license
|
package dys.clms.bean;
import java.util.ArrayList;
/**
* Created by Administrator on 2016/6/26 0026.
*/
public class Config {
private String configTitle;
private ArrayList<String> config;
public Config(String configTitle, ArrayList<String> config) {
this.configTitle = configTitle;
this.config = config;
}
public String getConfigTitle() {
return configTitle;
}
public void setConfigTitle(String configTitle) {
this.configTitle = configTitle;
}
public ArrayList<String> getConfig() {
return config;
}
public void setConfig(ArrayList<String> config) {
this.config = config;
}
}
| true
|
98d6e9e5cb7b1d7e7e7115aa2ac56eec9061f391
|
Java
|
erikarzumanyan/TravelManager
|
/app/src/main/java/com/uniquemiban/travelmanager/filter/MoneyFilterFragment.java
|
UTF-8
| 3,710
| 2.078125
| 2
|
[] |
no_license
|
package com.uniquemiban.travelmanager.filter;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v4.app.FragmentManager;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.EditText;
import com.uniquemiban.travelmanager.R;
import com.uniquemiban.travelmanager.start.NavigationDrawerActivity;
import com.uniquemiban.travelmanager.tour.TourListFragment;
public class MoneyFilterFragment extends DialogFragment {
public static final String FRAGMENT_TAG = "money_filter_fragment_tag";
public static final String SHARED_PREFS_MONEY = "shared_prefs_money";
public static final String SHARED_PREFS_KEY_FROM = "shared_prefs_money_from";
public static final String SHARED_PREFS_KEY_TO = "shared_prefs_money_to";
private SharedPreferences mPrefs;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mPrefs = getActivity().getSharedPreferences(SHARED_PREFS_MONEY, Context.MODE_PRIVATE);
}
@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
final View v = LayoutInflater.from(getActivity()).inflate(R.layout.fragment_money_filter, null);
final EditText fromEditText = (EditText)v.findViewById(R.id.edit_text_money_from);
final EditText toEditText = (EditText)v.findViewById(R.id.edit_text_money_to);
int from = mPrefs.getInt(SHARED_PREFS_KEY_FROM, -1);
int to = mPrefs.getInt(SHARED_PREFS_KEY_TO, -1);
if(from != -1)
fromEditText.setText("" + from);
if(to != -1)
toEditText.setText("" + to);
return new AlertDialog.Builder(getActivity())
.setTitle(R.string.action_money)
.setView(v)
.setPositiveButton("Save", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface pDialogInterface, int pI) {
String from = fromEditText.getText().toString();
String to = toEditText.getText().toString();
if(from != null && from.equals(""))
mPrefs.edit().putInt(SHARED_PREFS_KEY_FROM, -1).commit();
if(to != null && to.equals(""))
mPrefs.edit().putInt(SHARED_PREFS_KEY_TO, -1).commit();
Integer fromInt = null;
Integer toInt = null;
try {
fromInt = Integer.parseInt(from);
toInt = Integer.parseInt(to);
} catch (Exception e){}
if(fromInt != null)
mPrefs.edit().putInt(SHARED_PREFS_KEY_FROM, fromInt).commit();
if(toInt != null)
mPrefs.edit().putInt(SHARED_PREFS_KEY_TO, toInt).commit();
FragmentManager manager = ((NavigationDrawerActivity)getActivity()).getSupportFragmentManager();
if(manager.findFragmentByTag(TourListFragment.FRAGMENT_TAG) != null){
((TourListFragment)manager.findFragmentByTag(TourListFragment.FRAGMENT_TAG)).searchItemsByPrice();
}
}
})
.setNegativeButton("Cancel", null)
.create();
}
}
| true
|
e55e7562a0e80e25ab4d85cdf9447f01f762ca3a
|
Java
|
patiuma666/core-java-session9assignment3
|
/Employee.java
|
UTF-8
| 3,907
| 3.71875
| 4
|
[] |
no_license
|
package employeeExample;
public class Employee { //here we creating a class
int empId;
String empName;
int Total_Leaves;
double TotalSalary;
// here we are Creating the constructor of the Employee class
public Employee(int empId, String empName, int totalLeaves, double totalSalary) {
super();
this.empId = empId; //implementing the super keyword
this.empName = empName;
Total_Leaves = totalLeaves;
TotalSalary = totalSalary;
}
// here we are Creating the abstract method as calculate_balanceLeaves
void calculate_balanceLeaves(){
}
// here we are Creating the abstract method as avail_leave
boolean avail_leave(int no_of_leaves, char type_of_leave){
return true;
}
//here we are Creating the abstract methoda
void calculate_salary(){
}
}
class PermanentEmp extends Employee{ // here we Created a class PermanentEmp which is extends the Employee class
double basic,hra,pfa; //taking three variables of double data type
public PermanentEmp(int empId, String empName, int totalLeaves, double totalSalary) { //here implemented constructor of parent class
super(empId, empName, totalLeaves, totalSalary);
}
// here we are initializing the variables
int paid_leave=2,sick_leave=3,casual_leave=6;
//taking a Method to display leaves
void print_leave_details() {
System.out.println("paid_leave" + paid_leave + "sick_leave" + sick_leave + "casual_leave" + casual_leave);
}
void calculate_balanceLeaves() {// here overriding the calculate_balanceLeaves method
int balanceTotal=Total_Leaves-(paid_leave+sick_leave+casual_leave);
System.out.println("Total leaves left= "+balanceTotal);
}
boolean avail_leave(int no_of_leaves, char type_of_leave) {//here overriding the method
if( no_of_leaves< Total_Leaves){
return true;
}else{
return false;
}
}
void calculate_salary() { //Overriding the calculate_salary method
double hra=0.5f* basic;
double da= .2f * basic;
double totalSalary = TotalSalary + (hra + da) - pfa;
System.out.println("Salary of the employee is = "+ totalSalary);
}
}
//Creating a class TemporaryEmp which is extending Employee class
class TemporaryEmp extends Employee{
//Creating three variables
double basic,hra,pfa;
//Creating the constructor of the Employee class
public TemporaryEmp(int empId, String empName, int totalLeaves, double totalSalary) {
super(empId, empName, totalLeaves, totalSalary);
}
//initializing the variables
int paid_leave=2,sick_leave=3,casual_leave=7;
// Method to display leave details
void print_leave_details() {
System.out.println("paid_leave" + paid_leave + "sick_leave" + sick_leave + "casual_leave" + casual_leave);
}
//overriding the calculate_balanceLeaves method
void calculate_balanceLeaves() {
int balanceTotal=Total_Leaves-(paid_leave+sick_leave+casual_leave);
System.out.println("Total leaves left= "+balanceTotal);
}
//Overriding the calculate_salary method
boolean avail_leave(int no_of_leaves, char type_of_leave) {
if( no_of_leaves< Total_Leaves){
return true;
}else{
return false;
}
}
//Overriding the calculate_salary method
void calculate_salary() {
double hra=0.5f* basic;
double da= .2f * basic;
double totalSalary = TotalSalary + (hra + da) - pfa;
System.out.println("Salary of the employee is = "+ totalSalary);
}
}
| true
|
b470146b8c40d1547cc074d3c7b69193ce716d93
|
Java
|
wanderson100v/Locadora-veiculos-pajeu
|
/src/model/business/IBoEndereco.java
|
UTF-8
| 286
| 1.796875
| 2
|
[
"Apache-2.0"
] |
permissive
|
package model.business;
import model.excecoes.BoException;
import model.vo.Endereco;
public interface IBoEndereco extends IBussines<Endereco>{
public Endereco gerarEndereco(String cep) throws BoException;
public void validarEndereco(Endereco endereco) throws BoException;
}
| true
|
8b32d3b54c7bdf80385b0a0144a93c901f23a651
|
Java
|
Rardian/telegram-bots
|
/src/main/java/de/rardian/telegram/bot/castle/commands/actions/CastleStatusAction.java
|
UTF-8
| 675
| 2.3125
| 2
|
[] |
no_license
|
package de.rardian.telegram.bot.castle.commands.actions;
import de.rardian.telegram.bot.castle.model.Castle;
import de.rardian.telegram.bot.command.action.Action;
import de.rardian.telegram.bot.command.action.SendsAnswer;
import de.rardian.telegram.bot.communication.MessageReply;
public class CastleStatusAction implements Action, CastleAware, SendsAnswer {
private Castle castle;
private MessageReply reply;
@Override
public void setCastle(Castle castle) {
this.castle = castle;
}
@Override
public void setMessageReply(MessageReply reply) {
this.reply = reply;
}
@Override
public void execute() {
reply.answer(castle.getStatusAsString(), null);
}
}
| true
|
ef600b2f4875258b758a3aa1230d108b5dac2f39
|
Java
|
kasatkasss/TeachMeSkills
|
/Unit1Task2.java
|
UTF-8
| 441
| 3.3125
| 3
|
[] |
no_license
|
public class Unit1Task2 {
public static void main(String[] args) {
int a = 3;
int b = 9;
int c = 5;
if(((a+b) > c) && ((a + c) > b) && ((b+c) > a))
System.out.println("ะขัะตัะณะพะปัะฝะธะบ ั ัะฐะบะธะผะธ ััะพัะพะฝะฐะผะธ ัััะตััะฒัะตั");
else
System.out.println("ะขัะตัะณะพะปัะฝะธะบะฐ ั ัะฐะบะธะผะธ ััะพัะพะฝะฐะผะธ ะฝะต ัััะตััะฒัะตั");
}
}
| true
|
2dd5742a948867edeb1d316d434824b2e8680987
|
Java
|
Ekaterina5885/DZ-3.4.-MovieManager
|
/src/main/java/ru/netology/manager/MovieManager.java
|
UTF-8
| 1,366
| 2.8125
| 3
|
[] |
no_license
|
package ru.netology.manager;
import lombok.Data;
import lombok.NoArgsConstructor;
import ru.netology.domain.MovieList;
@Data
@NoArgsConstructor
public class MovieManager {
int quantityMovies = 10;
private MovieList[] movies = new MovieList[0];
public MovieManager(int quantityMovies) {
this.quantityMovies = quantityMovies;
}
public void setQuantityMovies(int quantityMovies){
if (quantityMovies < 0){
return;
}
this.quantityMovies = quantityMovies;
}
// ะะพะฑะฐะฒะธัั ัะธะปัะผั;
public void addMovies(MovieList item) {
int resultLength = movies.length + 1;
MovieList[] tmp = new MovieList[resultLength];
System.arraycopy(movies, 0, tmp, 0, movies.length);
int lastIndex = tmp.length - 1;
tmp[lastIndex] = item;
movies = tmp;
}
// ะัะดะฐัั ัะธะปัะผั ะฒ ะปะตะฝัั;
public MovieList[] getMovies() {
int resultLength;
if (movies.length > quantityMovies) {
resultLength = quantityMovies;
} else {
resultLength = movies.length;
}
MovieList[] result = new MovieList[resultLength];
for (int i = 0; i < resultLength; i++) {
int index = movies.length - i - 1;
result[i] = movies[index];
}
return result;
}
}
| true
|
43aec4a69847d86b0ac63d182b6e9caf2ba0108c
|
Java
|
GDayan/Shape
|
/src/main/java/dataparser/DataParser.java
|
UTF-8
| 1,441
| 3.03125
| 3
|
[] |
no_license
|
package dataparser;
import entity.Point;
import entity.Rectangle;
import validator.RectangleValidator;
import validator.ValueValidator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class DataParser {
private static final String REGEX_DELIMITER = "\\s++";
public List<Rectangle> parseData(List<String> linespoint){
List<Rectangle> rectangles = new ArrayList<>();
RectangleValidator validator = new RectangleValidator();
for(String line : linespoint){
if(validator.isValidRectangleData(line)){
List<Double> values = parseToDoubleArray(line);
rectangles.add(new Rectangle(new Point(values.get(0), values.get(1)))); //TODO // ะฒัะดะฐะตั ะพัะธะฑะบั
}
}
return rectangles;
}
public static List<Double> parseToDoubleArray(String line){
List<String> strings = parseToStringArray(line);
List<Double> values = new ArrayList<>();
ValueValidator validator = new ValueValidator();
for(String string : strings){
if(validator.isDouble(string)){
values.add(Double.parseDouble(string));
}
}
return values;
}
public static List<String> parseToStringArray(String line){
line = line.trim();
List<String> strings = Arrays.asList(line.split(REGEX_DELIMITER));
return strings;
}
}
| true
|
14ca3aadbfeba4f151c3ad896d0ae3ef9ed3a852
|
Java
|
No-Q/core
|
/src/main/java/com/noq/dependencies/db/dao/UserDao.java
|
UTF-8
| 314
| 2.15625
| 2
|
[] |
no_license
|
package com.noq.dependencies.db.dao;
import org.springframework.data.repository.CrudRepository;
import com.noq.dependencies.db.model.User;
public interface UserDao extends CrudRepository<User, Long>{
User findByName(String name);
User findByEmail(String email);
User findByPhone(String phone);
}
| true
|
bab1b91fdfcb29da91ca88456edc5a65a0c532f4
|
Java
|
kotelkonrad/I-Like-Wood
|
/src/main/java/yamahari/ilikewood/items/WoodenChestItem.java
|
UTF-8
| 1,105
| 2.1875
| 2
|
[
"MIT"
] |
permissive
|
package yamahari.ilikewood.items;
import net.minecraft.item.BlockItem;
import net.minecraft.item.Item;
import net.minecraft.item.ItemGroup;
import net.minecraft.item.ItemStack;
import yamahari.ilikewood.blocks.WoodenChestBlock;
import yamahari.ilikewood.tilenentities.renderer.WoodenChestItemStackTileEntityRenderer;
import yamahari.ilikewood.util.IWooden;
import yamahari.ilikewood.util.WoodType;
import yamahari.ilikewood.util.WoodenItemType;
import java.util.Objects;
public class WoodenChestItem extends BlockItem implements IWooden {
public WoodenChestItem(WoodenChestBlock block) {
super(block, (new Item.Properties()).group(ItemGroup.DECORATIONS).setTEISR(() -> WoodenChestItemStackTileEntityRenderer::new));
this.setRegistryName(Objects.requireNonNull(block.getRegistryName()));
}
@Override
public WoodType getWoodType() {
return ((WoodenChestBlock)this.getBlock()).getWoodType();
}
@Override
public int getBurnTime(ItemStack itemStack) {
return this.getWoodType().getWoodTypeProperties(WoodenItemType.CHEST).getBurnTime();
}
}
| true
|
564d464801b0a866ad03a8ef55587b7706f6e72c
|
Java
|
HongJungWan/kau-life
|
/app/src/main/java/com/lifekau/android/lifekau/activity/LibraryListActivity.java
|
UTF-8
| 10,970
| 2.125
| 2
|
[
"MIT",
"Apache-2.0"
] |
permissive
|
package com.lifekau.android.lifekau.activity;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.graphics.Color;
import android.os.AsyncTask;
import android.support.v4.graphics.ColorUtils;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import com.lifekau.android.lifekau.R;
import com.lifekau.android.lifekau.manager.LibraryManager;
import com.wdullaer.materialdatetimepicker.time.TimePickerDialog;
import java.lang.ref.WeakReference;
public class LibraryListActivity extends AppCompatActivity implements TimePickerDialog.OnTimeSetListener {
public static final int TYPE_READING_ROOM = 0;
public static final int TYPE_STUDY_ROOM = 1;
private static final String EXTRA_ROOM_TYPE = "extra_room_type";
private static final int TOTAL_READING_ROOM_NUM = 5;
private static final int TOTAL_STUDY_ROOM_NUM = 6;
private LibraryManager mLibraryManager = LibraryManager.getInstance();
private RecyclerView mRecyclerView;
private RecyclerView.Adapter mRecyclerAdapter;
private ProgressBar mProgressBar;
private int mRoomType;
private int mSelectedArray;
public static Intent newIntent(Context context, int roomType) {
Intent intent = new Intent(context, LibraryListActivity.class);
intent.putExtra(EXTRA_ROOM_TYPE, roomType);
return intent;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activitiy_library_list);
if (getSupportActionBar() != null) {
// getSupportActionBar().setDisplayShowTitleEnabled(false);
getSupportActionBar().hide();
}
Intent intent = getIntent();
mRoomType = intent.getIntExtra(EXTRA_ROOM_TYPE, TYPE_READING_ROOM);
mSelectedArray =
mRoomType == TYPE_READING_ROOM ? R.array.library_reading_room_list : R.array.library_study_room_list;
mRecyclerAdapter = new RecyclerView.Adapter<LibraryListViewHolder>() {
@Override
public LibraryListViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item_library, parent, false);
return new LibraryListViewHolder(view);
}
@Override
public void onBindViewHolder(LibraryListViewHolder holder, int position) {
holder.bind(position);
}
@Override
public int getItemCount() {
return getResources().getStringArray(mSelectedArray).length;
}
};
mRecyclerView = (RecyclerView) findViewById(R.id.library_list_recycler_view);
mRecyclerView.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
mRecyclerView.setAdapter(mRecyclerAdapter);
mProgressBar = findViewById(R.id.library_list_progress_bar);
mProgressBar.setVisibility(View.VISIBLE);
mRecyclerView.setVisibility(View.GONE);
LibraryManagerAsyncTask libraryManagerAsyncTask = new LibraryManagerAsyncTask(getApplication(), this);
libraryManagerAsyncTask.execute();
}
public class LibraryListViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
private TextView mNameTextView;
private TextView mDetailTextView;
private View mItemView;
public LibraryListViewHolder(View itemView) {
super(itemView);
mItemView = itemView;
mNameTextView = itemView.findViewById(R.id.list_item_library_item_name);
mDetailTextView = itemView.findViewById(R.id.list_item_library_item_detail);
itemView.setOnClickListener(this);
}
public void bind(int position) {
mItemView.setBackgroundColor(Color.WHITE);
if (mRoomType == TYPE_READING_ROOM) {
mNameTextView.setText(mLibraryManager.getReadingRoomName(position));
int cntAvailableSeat = mLibraryManager.getReadingRoomAvailableSeat(position);
int cntTotalSeat = mLibraryManager.getReadingRoomTotalSeat(position);
String statusString;
String format = getString(R.string.library_reading_room_detail_format);
statusString = String.format(format, cntTotalSeat - cntAvailableSeat, cntAvailableSeat);
// mItemView.setBackgroundColor(Color.WHITE);
if (cntAvailableSeat == 0) {
mItemView.setBackgroundColor(changeAlpha(Color.RED, 0.15f));
mDetailTextView.setTextColor(getResources().getColor(R.color.room_not_available_color));
}
// else if(cntAvailableSeat < cntTotalSeat / 2){
// mDetailTextView.setTextColor(getResources().getColor(R.color.orange));
// }
else {
// mItemView.setBackgroundColor(changeAlpha(Color.GREEN, 0.15f));
mDetailTextView.setTextColor(getResources().getColor(R.color.room_available_color));
}
mDetailTextView.setText(statusString);
} else if (mRoomType == TYPE_STUDY_ROOM) {
mNameTextView.setText(getResources().getStringArray(R.array.library_study_room_list)[position]);
boolean isAvailableNow = mLibraryManager.isStudyRoomAvailableNow(position);
Log.e("ERROR", "position" + position + " " + "์ด์ฉ ๊ฐ๋ฅ ์ฌ๋ถ " + isAvailableNow);
String format = getString(R.string.library_study_room_detail_format);
if (!isAvailableNow) {
mDetailTextView.setText(String.format(format, getString(R.string.not_available_now)));
mItemView.setBackgroundColor(changeAlpha(Color.RED, 0.15f));
mDetailTextView.setTextColor(getResources().getColor(R.color.room_not_available_color));
} else {
mDetailTextView.setText(String.format(format, getString(R.string.available_now)));
mItemView.setBackgroundColor(Color.WHITE);
mDetailTextView.setTextColor(getResources().getColor(R.color.room_available_color));
}
}
}
private int changeAlpha(int color, float percent) {
return ColorUtils.setAlphaComponent(color, (int) (255 * percent));
}
@Override
public void onClick(View view) {
if (mRoomType == TYPE_READING_ROOM) {
Intent intent = ReadingRoomDetailActivity.newIntent(view.getContext());
intent.putExtra(EXTRA_ROOM_TYPE, getAdapterPosition() + 1);
startActivity(intent);
} else mLibraryManager.showStudyRoomStatus(view.getContext(), getAdapterPosition());
}
}
@Override
protected void onResume() {
super.onResume();
if (mRecyclerAdapter != null) {
mRecyclerAdapter.notifyDataSetChanged();
}
}
private static class LibraryManagerAsyncTask extends AsyncTask<Void, Void, Integer> {
private WeakReference<LibraryListActivity> activityReference;
private WeakReference<Application> applicationWeakReference;
// only retain a weak reference to the activity
LibraryManagerAsyncTask(Application application, LibraryListActivity libraryListActivity) {
applicationWeakReference = new WeakReference<>(application);
activityReference = new WeakReference<>(libraryListActivity);
}
@Override
protected Integer doInBackground(Void... params) {
LibraryListActivity libraryListActivity = activityReference.get();
Resources resources = applicationWeakReference.get().getResources();
if (libraryListActivity == null || libraryListActivity.isFinishing())
return resources.getInteger(R.integer.unexpected_error);
LibraryManager lm = libraryListActivity.mLibraryManager;
int result;
int count = 0;
for (int i = 0; i < TOTAL_STUDY_ROOM_NUM; i++) {
while (!isCancelled() && (result = lm.pullStudyRoomDetailStatus(applicationWeakReference.get(), i)) != resources.getInteger(R.integer.no_error)) {
if (result == resources.getInteger(R.integer.network_error)) {
count++;
} else return result;
if (count == resources.getInteger(R.integer.maximum_retry_num))
return resources.getInteger(R.integer.network_error);
}
}
while (!isCancelled() && (result = lm.pullReadingRoomStatus(applicationWeakReference.get())) != resources.getInteger(R.integer.no_error)) {
if (result == resources.getInteger(R.integer.network_error)) {
count++;
} else return result;
if (count == resources.getInteger(R.integer.maximum_retry_num))
return resources.getInteger(R.integer.network_error);
}
return resources.getInteger(R.integer.no_error);
}
@Override
protected void onPostExecute(Integer result) {
super.onPostExecute(result);
LibraryListActivity libraryListActivity = activityReference.get();
Resources resources = applicationWeakReference.get().getResources();
if (libraryListActivity == null || libraryListActivity.isFinishing()) return;
if (result == resources.getInteger(R.integer.no_error)) {
libraryListActivity.mRecyclerAdapter.notifyDataSetChanged();
} else if (result == resources.getInteger(R.integer.network_error)) {
libraryListActivity.showErrorMessage();
}
ProgressBar progressBar = libraryListActivity.findViewById(R.id.library_list_progress_bar);
RecyclerView recyclerView = libraryListActivity.findViewById(R.id.library_list_recycler_view);
progressBar.setVisibility(View.GONE);
recyclerView.setVisibility(View.VISIBLE);
}
}
public void showErrorMessage() {
Toast toast = Toast.makeText(this, "๋คํธ์ํฌ ์ค๋ฅ๊ฐ ๋ฐ์ํ์์ต๋๋ค.", Toast.LENGTH_SHORT);
toast.show();
}
@Override
public void onTimeSet(TimePickerDialog view, int hourOfDay, int minute, int second) {
}
}
| true
|
dd0f52a579b78e069c555161f27792ebd8b1cd43
|
Java
|
Kahzerx/RiftedCarpet
|
/src/main/java/carpet/mixins/rule/shulkerSpawningInEndCities/ChunkGeneratorEndMixin.java
|
UTF-8
| 1,282
| 1.890625
| 2
|
[] |
no_license
|
package carpet.mixins.rule.shulkerSpawningInEndCities;
import carpet.CarpetSettings;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IWorld;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.provider.BiomeProvider;
import net.minecraft.world.gen.AbstractChunkGenerator;
import net.minecraft.world.gen.ChunkGeneratorEnd;
import net.minecraft.world.gen.EndGenSettings;
import net.minecraft.world.gen.feature.Feature;
import org.spongepowered.asm.mixin.Mixin;
import java.util.List;
@Mixin(ChunkGeneratorEnd.class)
public abstract class ChunkGeneratorEndMixin extends AbstractChunkGenerator<EndGenSettings> {
public ChunkGeneratorEndMixin(IWorld worldIn, BiomeProvider biomeProviderIn) {
super(worldIn, biomeProviderIn);
}
@Override
public List<Biome.SpawnListEntry> getPossibleCreatures(EnumCreatureType creatureType, BlockPos pos) {
if (CarpetSettings.shulkerSpawningInEndCities && EnumCreatureType.MONSTER == creatureType) {
if (Feature.END_CITY.isPositionInsideStructure(this.world, pos)) {
return Feature.END_CITY.getSpawnList();
}
}
return this.world.getBiome(pos).getSpawns(creatureType);
}
}
| true
|
52cd03004c06300fb85b7f4966fd831c87e14ba6
|
Java
|
gaur-shubham/StimOpti
|
/Stimopti/src/main/java/com/petroleumsoft/stimopti/services/ChartsService.java
|
UTF-8
| 489
| 1.820313
| 2
|
[] |
no_license
|
package com.petroleumsoft.stimopti.services;
import java.util.List;
import com.petroleumsoft.stimopti.modal.Penetration;
import com.petroleumsoft.stimopti.modal.Placement;
import com.petroleumsoft.stimopti.modal.Productivity;
import com.petroleumsoft.stimopti.modal.Skin;
public interface ChartsService {
public List<Penetration> penetration(Integer pid);
public List<Placement> placement(Integer pid);
public List<Skin> skin(Integer pid);
public List<Productivity> pi(Integer pid);
}
| true
|
ae4594053a44a0a67660c21290df74b43fc58261
|
Java
|
lanhoter/Leet-Code-Youtube
|
/Java/Google/23 - Merge k Sorted Lists/MergeKSortedList.java
|
UTF-8
| 797
| 3.671875
| 4
|
[] |
no_license
|
public class MergeKSortedList {
public ListNode mergeKLists(ListNode[] lists) {
PriorityQueue<ListNode> minHeap = createMinHeap(lists);
ListNode head = new ListNode(), tail = head;
while (!minHeap.isEmpty()) {
ListNode node = minHeap.poll();
tail.next = node;
tail = node;
if (node.next != null) {
minHeap.add(node.next);
}
}
return head.next;
}
private PriorityQueue<ListNode> createMinHeap(ListNode[] lists) {
PriorityQueue<ListNode> minHeap = new PriorityQueue<>((n1, n2) -> n1.val - n2.val);
for (ListNode list: lists) {
if (list != null) {
minHeap.add(list);
}
}
return minHeap;
}
}
| true
|
00d11712535d49382d943e94667c39f9dbf719c2
|
Java
|
slapa97/db-service
|
/src/main/java/com/piotrek/stock/dbservice/configuration/HibernateConfiguration.java
|
UTF-8
| 908
| 2.078125
| 2
|
[] |
no_license
|
package com.piotrek.stock.dbservice.configuration;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@Configuration
@EnableTransactionManagement
public class HibernateConfiguration {
@Bean
public DataSource dataSource() {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/sys?useSSL=false&useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&allowPublicKeyRetrieval=true");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}
}
| true
|
c23fa0aeb3ae05329b07a2dda13c033a853c5f45
|
Java
|
kt-shashi/DsAlgo.Java
|
/searchingandsorting/IndexOfFirst1InBinarySortedInfiniteArray.java
|
UTF-8
| 1,808
| 4.28125
| 4
|
[] |
no_license
|
package com.shashi.dsalgo.searchingandsorting;
//Given an infinite sorted array consisting 0s and 1s.
// The problem is to find the index of first โ1โ in
// that array. As the array is infinite, therefore
// it is guaranteed that number โ1โ will be
// present in the array.
//Approach
//Find the bound in which 1 lies
//Find the first occurrence
//To find bound, we shift end to right until we find
//an element that is greater than a[previous]
//To find first occurence of 1
//We check if a[ mid ] is 1
//If yes, then it may be a possible ans, or
//there ,might be a lesser index.
//Hence, we store the index, and continue searching
//In the left side of the array
//Otherwise if we encounter a index with value lesser than 1,
//we try finding to the right side of the array
public class IndexOfFirst1InBinarySortedInfiniteArray {
//Function to find first position of 1
public static int posOfFirstOne(int[] a) {
int start = 0;
int end = a.length - 1;
while (a[end] < 1) {
start = end;
end = end * 2;
}
int answer = findFirstOccurence(a, start, end);
return answer;
}
//Utility function to find the first position
//in a given bound
private static int findFirstOccurence(int[] a, int start, int end) {
int answer = -1;
while (start <= end) {
int mid = start + (end - start) / 2;
if (a[mid] == 1) {
answer = mid;
end = mid - 1;
} else if (a[mid] < 1) {
start = mid + 1;
}
}
return answer;
}
public static void main(String[] args) {
int arr[] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
System.out.println("Index = " + posOfFirstOne(arr));
}
}
| true
|
73784211d6c1bfc8390ec204e693f3e4f8a8260f
|
Java
|
jacksonrick/JFrameBoot
|
/jframe-core/src/main/java/com/jf/system/conf/FdfsConfig.java
|
UTF-8
| 3,281
| 1.953125
| 2
|
[
"BSD-3-Clause"
] |
permissive
|
package com.jf.system.conf;
import com.jf.sdk.fdfs.conn.*;
import com.jf.sdk.fdfs.service.*;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
/**
* Created with IntelliJ IDEA.
* Description: FastDFS
* User: xujunfei
* Date: 2018-01-19
* Time: 14:20
*/
@Configuration
@ConditionalOnProperty(name = "system.upload.fdfs", havingValue = "true")
@ConfigurationProperties(prefix = "fdfs")
public class FdfsConfig {
// ่ฏปๅๆถ้ด๏ผ้ป่ฎค1000
private int soTimeout = 2000;
// ่ฟๆฅ่ถ
ๆถๆถ้ด
private int connectTimeout = 2000;
// Tracker ๅฐๅๅ่กจ
private List<String> trackerList = new ArrayList<>();
@Bean
public PooledConnectionFactory pooledConnectionFactory() {
PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
pooledConnectionFactory.setSoTimeout(soTimeout);
pooledConnectionFactory.setConnectTimeout(connectTimeout);
return pooledConnectionFactory;
}
@Bean
@ConfigurationProperties(prefix = "fdfs.pool")
public ConnectionPoolConfig connectionPoolConfig() {
ConnectionPoolConfig connectionPoolConfig = new ConnectionPoolConfig();
return connectionPoolConfig;
}
@Bean
public FdfsConnectionPool fdfsConnectionPool(PooledConnectionFactory pooledConnectionFactory, ConnectionPoolConfig connectionPoolConfig) {
FdfsConnectionPool pool = new FdfsConnectionPool(pooledConnectionFactory, connectionPoolConfig);
return pool;
}
@Bean
public TrackerConnectionManager trackerConnectionManager(FdfsConnectionPool fdfsConnectionPool) {
return new TrackerConnectionManager(fdfsConnectionPool, trackerList);
}
@Bean
public TrackerClient trackerClient(TrackerConnectionManager trackerConnectionManager) {
return new DefaultTrackerClient(trackerConnectionManager);
}
@Bean
public ConnectionManager connectionManager(FdfsConnectionPool fdfsConnectionPool) {
return new ConnectionManager(fdfsConnectionPool);
}
@Bean
public FastFileStorageClient fastFileStorageClient(TrackerClient trackerClient, ConnectionManager connectionManager) {
return new DefaultFastFileStorageClient(trackerClient, connectionManager);
}
@Bean
public AppendFileStorageClient appendFileStorageClient(TrackerClient trackerClient, ConnectionManager connectionManager) {
return new DefaultAppendFileStorageClient(trackerClient, connectionManager);
}
public int getSoTimeout() {
return soTimeout;
}
public void setSoTimeout(int soTimeout) {
this.soTimeout = soTimeout;
}
public int getConnectTimeout() {
return connectTimeout;
}
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
public List<String> getTrackerList() {
return trackerList;
}
public void setTrackerList(List<String> trackerList) {
this.trackerList = trackerList;
}
}
| true
|
e0b473b91ec58907c450102a4d39927152a5320a
|
Java
|
lucascalsilva/camunda-custom-rest-controller-demo
|
/src/main/java/com/camunda/consulting/dto/CustomCompleteTaskDto.java
|
UTF-8
| 652
| 1.898438
| 2
|
[] |
no_license
|
package com.camunda.consulting.dto;
import org.camunda.bpm.engine.rest.dto.task.CompleteTaskDto;
import org.camunda.bpm.engine.rest.dto.task.UserIdDto;
public class CustomCompleteTaskDto {
private UserIdDto userIdDto;
private CompleteTaskDto completeTaskDto;
public UserIdDto getUserIdDto() {
return userIdDto;
}
public void setUserIdDto(UserIdDto userIdDto) {
this.userIdDto = userIdDto;
}
public CompleteTaskDto getCompleteTaskDto() {
return completeTaskDto;
}
public void setCompleteTaskDto(CompleteTaskDto completeTaskDto) {
this.completeTaskDto = completeTaskDto;
}
}
| true
|
04132f9e53763835f8579e49959293fb4cb66069
|
Java
|
clarck/leetcode-1
|
/src/main/java/com/example/leetcode/binarytree/LeetCode617_MergeTwoBinaryTrees.java
|
UTF-8
| 2,188
| 3.90625
| 4
|
[] |
no_license
|
package com.example.leetcode.binarytree;
import com.example.leetcode.linkedlist.pojo.TreeNode;
import java.util.Stack;
/**
* @description: ๅๅนถไบๅๆ
* ็ปๅฎไธคไธชไบๅๆ ๏ผๆณ่ฑกๅฝไฝ ๅฐๅฎไปฌไธญ็ไธไธช่ฆ็ๅฐๅฆไธไธชไธๆถ๏ผไธคไธชไบๅๆ ็ไธไบ่็นไพฟไผ้ๅ ใ
*
* ไฝ ้่ฆๅฐไปไปฌๅๅนถไธบไธไธชๆฐ็ไบๅๆ ใๅๅนถ็่งๅๆฏๅฆๆไธคไธช่็น้ๅ ๏ผ้ฃไนๅฐไปไปฌ็ๅผ็ธๅ ไฝไธบ่็นๅๅนถๅ็ๆฐๅผ๏ผๅฆๅไธไธบย NULL ็่็นๅฐ็ดๆฅไฝไธบๆฐไบๅๆ ็่็นใ
*
* ็คบไพย 1:
*
* ่พๅ
ฅ:
* Tree 1 Tree 2
* 1 2
* / \ / \
* 3 2 1 3
* / \ \
* 5 4 7
* ่พๅบ:
* ๅๅนถๅ็ๆ :
* 3
* / \
* 4 5
* / \ \
* 5 4 7
* ๆณจๆ:ย ๅๅนถๅฟ
้กปไปไธคไธชๆ ็ๆ น่็นๅผๅงใ
* @author: icecrea
* @create: 2020-01-10
**/
public class LeetCode617_MergeTwoBinaryTrees {
public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
if (t1 == null) {
return t2;
}
if (t2 == null) {
return t1;
}
t1.val += t2.val;
t1.left = mergeTrees(t1.left, t2.left);
t1.right = mergeTrees(t1.right, t2.right);
return t1;
}
public TreeNode mergeTrees2(TreeNode t1, TreeNode t2) {
if (t1 == null) {
return t2;
}
Stack<TreeNode[]> stack = new Stack<>();
stack.push(new TreeNode[]{t1, t2});
while (!stack.isEmpty()) {
TreeNode[] nodes = stack.pop();
if (nodes[0] == null || nodes[1] == null) {
continue;
}
nodes[0].val += nodes[1].val;
if (nodes[0].left == null) {
nodes[0].left = nodes[1].left;
} else {
stack.push(new TreeNode[]{nodes[0].left, nodes[1].left});
}
if (nodes[0].right == null) {
nodes[0].right = nodes[1].right;
} else {
stack.push(new TreeNode[]{nodes[0].right, nodes[1].right});
}
}
return t1;
}
}
| true
|
1ef3a743df6f7e0b3a78a5dcf3b0b660f892aefe
|
Java
|
zhanght86/medical
|
/education/projects/ThunderReportEZ/src/com/teamsun/thunderreport/thread/support/ConfigurationFileService.java
|
UTF-8
| 1,028
| 2.140625
| 2
|
[] |
no_license
|
package com.teamsun.thunderreport.thread.support;
import java.io.File;
import java.io.FilenameFilter;
public interface ConfigurationFileService {
/**
* ่ทๅ้
็ฝฎๆไปถไฟกๆฏ
*
* @return
*/
public File[] listAllConfigurationFiles(FilenameFilter filter);
/**
* ่ทๅๅ
จ้จ้
็ฝฎๆไปถไฟกๆฏ
*
* @return
*/
public File[] listAllConfigurationFiles();
/**
* ๆ นๆฎ็ปๅฎ็ๆไปถๅพๅฐ้
็ฝฎๆไปถไฟกๆฏ
*
*
* @param filename
* @return
*/
public File getFileByName(String filename);
/**
* ๆ นๆฎ็ปๅฎ็ๆฅ่กจid่ทๅ้
็ฝฎๆไปถ
*
* @param reportId
* @return
*/
public File getFileByReportId(String reportId);
/**
* ๆ นๆฎ็ปๅฎ็ๆฅ่กจid่ทๅ้ข็ๆ็ๆฅ่กจ้
็ฝฎๆไปถ
*
* @param reportId
* @return
*/
public File getPreFileByReportId(String reportId);
/**
* ่ทๅ้ข็ๆ้
็ฝฎๆไปถไฟกๆฏ
*
* @return
*/
public File[] listAllPreConfigurationFiles(FilenameFilter filter);
}
| true
|
19d0591dad54ebe8bb096855185a0cea47637d4c
|
Java
|
dbeaver/dbeaver
|
/plugins/org.jkiss.dbeaver.ext.generic/src/org/jkiss/dbeaver/ext/generic/edit/GenericTableManager.java
|
UTF-8
| 6,043
| 1.507813
| 2
|
[
"Apache-2.0",
"EPL-1.0",
"LGPL-2.0-or-later"
] |
permissive
|
/*
* DBeaver - Universal Database Manager
* Copyright (C) 2010-2023 DBeaver Corp and others
*
* 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.jkiss.dbeaver.ext.generic.edit;
import org.jkiss.code.NotNull;
import org.jkiss.code.Nullable;
import org.jkiss.dbeaver.DBException;
import org.jkiss.dbeaver.ext.generic.GenericConstants;
import org.jkiss.dbeaver.ext.generic.model.*;
import org.jkiss.dbeaver.model.DBConstants;
import org.jkiss.dbeaver.model.DBPEvaluationContext;
import org.jkiss.dbeaver.model.DBPObject;
import org.jkiss.dbeaver.model.edit.DBECommandContext;
import org.jkiss.dbeaver.model.edit.DBEObjectManager;
import org.jkiss.dbeaver.model.edit.DBEPersistAction;
import org.jkiss.dbeaver.model.exec.DBCExecutionContext;
import org.jkiss.dbeaver.model.impl.edit.SQLDatabasePersistAction;
import org.jkiss.dbeaver.model.impl.sql.edit.struct.SQLTableManager;
import org.jkiss.dbeaver.model.navigator.DBNDatabaseFolder;
import org.jkiss.dbeaver.model.navigator.DBNNode;
import org.jkiss.dbeaver.model.navigator.meta.DBXTreeItem;
import org.jkiss.dbeaver.model.navigator.meta.DBXTreeNode;
import org.jkiss.dbeaver.model.runtime.DBRProgressMonitor;
import org.jkiss.dbeaver.model.sql.SQLUtils;
import org.jkiss.dbeaver.model.struct.DBSEntityConstraint;
import org.jkiss.dbeaver.model.struct.DBSObject;
import org.jkiss.dbeaver.model.struct.cache.DBSObjectCache;
import org.jkiss.dbeaver.model.struct.rdb.DBSTableIndex;
import org.jkiss.utils.CommonUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* Generic table manager
*/
public class GenericTableManager extends SQLTableManager<GenericTableBase, GenericStructContainer> {
private static final Class<? extends DBSObject>[] CHILD_TYPES = CommonUtils.array(
GenericTableColumn.class,
GenericUniqueKey.class,
GenericTableForeignKey.class,
GenericTableIndex.class
);
@Nullable
@Override
public DBSObjectCache<? extends DBSObject, GenericTableBase> getObjectsCache(GenericTableBase object)
{
return object.getContainer().getTableCache();
}
@NotNull
@Override
public Class<? extends DBSObject>[] getChildTypes()
{
return CHILD_TYPES;
}
@Override
public boolean canCreateObject(Object container) {
return super.canCreateObject(container);
}
@Override
protected GenericTableBase createDatabaseObject(DBRProgressMonitor monitor, DBECommandContext context, Object container, Object copyFrom, Map<String, Object> options)
{
GenericStructContainer structContainer = (GenericStructContainer) container;
boolean isView = false;
Object navContainer = options.get(DBEObjectManager.OPTION_CONTAINER);
if (navContainer instanceof DBNDatabaseFolder) {
List<DBXTreeNode> folderChildren = ((DBNDatabaseFolder) navContainer).getMeta().getChildren((DBNNode) navContainer);
if (folderChildren.size() == 1 && folderChildren.get(0) instanceof DBXTreeItem && ((DBXTreeItem) folderChildren.get(0)).getPropertyName().equals("views")) {
isView = true;
}
}
String tableName = getNewChildName(monitor, structContainer, isView ? BASE_VIEW_NAME : BASE_TABLE_NAME);
return structContainer.getDataSource().getMetaModel().createTableOrViewImpl(structContainer, tableName,
isView ? GenericConstants.TABLE_TYPE_VIEW : GenericConstants.TABLE_TYPE_TABLE,
null);
}
@Override
protected boolean excludeFromDDL(NestedObjectCommand command, Collection<NestedObjectCommand> orderedCommands) {
// Filter out indexes for unique constraints (if they have the same name)
DBPObject object = command.getObject();
if (object instanceof DBSTableIndex) {
for (NestedObjectCommand ccom : orderedCommands) {
if (ccom.getObject() instanceof DBSEntityConstraint &&
ccom.getObject() != object &&
((DBSEntityConstraint) ccom.getObject()).getConstraintType().isUnique() &&
CommonUtils.equalObjects(
((DBSTableIndex) object).getName(), ((DBSEntityConstraint) ccom.getObject()).getName()))
{
return true;
}
}
}
return false;
}
@Override
protected void addObjectExtraActions(DBRProgressMonitor monitor, DBCExecutionContext executionContext, List<DBEPersistAction> actions, NestedObjectCommand<GenericTableBase, PropertyHandler> command, Map<String, Object> options) throws DBException {
GenericTableBase tableBase = command.getObject();
if (command.hasProperty(DBConstants.PROP_ID_DESCRIPTION)) {
actions.add(new SQLDatabasePersistAction(
"Comment table",
"COMMENT ON TABLE " + tableBase.getFullyQualifiedName(DBPEvaluationContext.DDL) +
" IS " + SQLUtils.quoteString(tableBase, CommonUtils.notEmpty(tableBase.getDescription()))));
}
if (!tableBase.isPersisted()) {
// Column comments for the newly created table
for (GenericTableColumn column : CommonUtils.safeCollection(tableBase.getAttributes(monitor))) {
if (!CommonUtils.isEmpty(column.getDescription())) {
GenericTableColumnManager.addColumnCommentAction(actions, column, column.getTable());
}
}
}
}
}
| true
|
0b956bad431f8d956bb757399f4510371c5cebe3
|
Java
|
dmnm/booleanDocValues-jmh-tests
|
/src/main/java/org/apache/lucene/codec/IndexingBooleanDocValuesBench.java
|
UTF-8
| 4,897
| 2.140625
| 2
|
[] |
no_license
|
package org.apache.lucene.codec;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import org.apache.lucene.codecs.DocValuesFormat;
import org.apache.lucene.codecs.bool.BooleanDocValuesFormat;
import org.apache.lucene.codecs.lucene80.Lucene80Codec;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericDocValuesField;
import org.apache.lucene.document.StringField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.FSDirectory;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.VerboseMode;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 2, time = 2)
@Measurement(iterations = 3, time = 3)
@Fork(value = 1)
@State(Scope.Benchmark)
public class IndexingBooleanDocValuesBench {
private static final String TEMPORARY_PATH = "/tmp/bench";
@Param({ "10", "35", "50", "60", "90" })
private int density = 90;
//@Param({ "1", "2", "3", "4", "5", "10" })
private int numSegments = 1;
@Param({ "dense", "sparse" })
private String compression;
@Param({ "false", "true" })
private boolean useBooleanCodec;
private final int maxDoc = 2_000_000;
private String store;
private Random random = new Random();
private IndexWriter writer;
public static void main(String[] args) throws Exception {
Options options = new OptionsBuilder().include(IndexingBooleanDocValuesBench.class.getName())
.forks(2)
.verbosity(VerboseMode.NORMAL)
.resultFormat(ResultFormatType.JSON)
.build();
new Runner(options).run();
}
@Setup
public void init() throws IOException {
store = (useBooleanCodec ? "boolean_" : "") + "store_" + density;
FSDirectory directory = FSDirectory.open(new File(TEMPORARY_PATH).toPath());
IndexWriterConfig conf = new IndexWriterConfig(null).setOpenMode(IndexWriterConfig.OpenMode.CREATE)
.setCodec(new BooleanCodec())
.setUseCompoundFile(false)
.setMaxBufferedDocs(500000)
.setRAMBufferSizeMB(1024);
writer = new IndexWriter(directory, conf);
}
@Benchmark
public int createIndex() throws IOException {
int numTrueValues = 0;
boolean checkSparseDv = "sparse".equals(compression);
float probability = density / 100f;
for (int i = 0; i < maxDoc; i++) {
Document doc = new Document();
doc.add(new StringField("id", String.valueOf(i), Field.Store.NO));
if (random.nextFloat() < probability) {
numTrueValues++;
doc.add(new NumericDocValuesField(store, 1));
} else if (!checkSparseDv || random.nextBoolean()) { //to check different compressions (Lucene80DocValuesProducer$SparseNumericDocValues vs Lucene80DocValuesProducer$DenseNumericDocValues)
doc.add(new NumericDocValuesField(store, 0));
}
writer.addDocument(doc);
}
writer.forceMerge(numSegments);
writer.commit();
return numTrueValues;
}
/**
* Simple example codec with ability to create {@link BooleanDocValuesFormat} as default implementation always
* returns "Lucene80" format for any field.
*/
public static class BooleanCodec extends Lucene80Codec {
private final DocValuesFormat booleanDVFormat = DocValuesFormat.forName("Boolean");
@Override
public DocValuesFormat getDocValuesFormatForField(String field) {
if (field.startsWith("boolean_")) {
return booleanDVFormat;
} else {
return super.getDocValuesFormatForField(field);
}
}
}
}
| true
|
e265546d653126a3efac2bc098888772003dd392
|
Java
|
YangLiuSong/Java-lgta
|
/lgta/src/lgta.java
|
UTF-8
| 21,792
| 2.46875
| 2
|
[] |
no_license
|
import java.io.*;
import java.util.*;
import Jama.Matrix;
public class lgta {
// ๅฃฐๆๆๆ็ๅๆฐ
// ่ฏ่ฏญwords็้ๅ
private HashSet<String> words = new HashSet<String>();
// ๅ่ฏwๅจๆๆกฃdไธญๅบ็ฐ็้ขๆฐ๏ผc(w,d)
private List<Map<String,Double>> c_w_d = new ArrayList<>();
// ๆๆกฃๆปๆฐ
private int doc_num;
// ไธป้ขๆฐ
private int topic_num;
// ๅบๅๆฐ
private int region_num;
// ๅๆฐ LambdaB
private double LambdaB;
// ๆป่ฏๆฐ
private double all_count;
// ๅๆๆกฃ็ป็บฌๅบฆไฟกๆฏ || Shape:doc_num * Matrix
private List<Matrix> l_d = new ArrayList<>();
// First-EM ้่ๅ้ p(r|d,Variable) || Shape:doc_num * region_num
private double[][] p_r_dVariable;
// Second-EM ้่ๅ้ sigma(w,r,z) || Shape: topic_num * region_num * words.size()
private Map<String,Double>[][] sigma_wrz;
// ๅฐ็ไธป้ข็ปๆp(z|l,Variable) || Shape:doc_num * topic_num
private double[][] p_z_lVariable;
public HashSet<String> getWords() {
return words;
}
public List<Map<String, Double>> getC_w_d() {
return c_w_d;
}
public int getDoc_num() {
return doc_num;
}
public double getAll_count() {
return all_count;
}
public List<Matrix> getL_d() {
return l_d;
}
public double[][] getP_r_dVariable() {
return p_r_dVariable;
}
public Map<String, Double>[][] getSigma_wrz() {
return sigma_wrz;
}
public double[][] getP_z_lVariable() {
return p_z_lVariable;
}
public double[][] getP_z_r() {
return p_z_r;
}
public List<Map<String, Double>> getP_w_z() {
return p_w_z;
}
public double[] getP_r_alpha() {
return p_r_alpha;
}
public List<Matrix> getR_E() {
return r_E;
}
public List<Matrix> getR_D() {
return r_D;
}
// EM็ฎๆณๆดๆฐ็ๅๆฐ
// ๅๅบๅๅ
ๆฏไธชไธป้ข็ๆฆ็ๅๅธp(z|r) || Listๅฝข็ถ๏ผregion_num * topic_num
private double[][] p_z_r;
// ๅไธป้ขๅ
ๆฏไธชๅ่ฏ็ๆฆ็ๅๅธp(w|z) || Listๅฝข็ถ๏ผtopic_num * words.size()
private List<Map<String,Double>> p_w_z = new ArrayList<>();
// ๅบๅๆ้ๆฆ็ๅๅธp(r|alpha) || Listๅฝข็ถ๏ผregion_num
private double[] p_r_alpha;
// ๅบๅr็ๆๆEไธๅๆนๅทฎD
private List<Matrix> r_E = new ArrayList<>(); // Shape:region * Matrix
private List<Matrix> r_D = new ArrayList<>(); // Shape:region * Matrix
// ๅฃฐๆๆๆ็ๅๆฐ End
private String inputPath;
// ๆ้ ๅฝๆฐ
public lgta(double LambdaB,int topic_num,int region_num){
this.LambdaB = LambdaB;
this.topic_num = topic_num;
this.region_num = region_num;
}
// ่ฏปๅๆฐๆฎ
public boolean load_data(String document_path,String rE_path,String rD_path){
this.inputPath = document_path;
double[] r_init = new double[this.region_num];
double r_sum = 0;
try {
BufferedReader csvreader = new BufferedReader(new FileReader(document_path));
String line = null;
while((line=csvreader.readLine())!=null){
String[] items = line.split(",");//CSVๆ ผๅผๆไปถไธบ้ๅทๅ้็ฌฆๆไปถ๏ผ่ฟ้ๆ นๆฎ้ๅทๅๅ
double[][] l = {{Double.parseDouble(items[0].substring(2)),Double.parseDouble(items[1].substring(0,items[1].length()-2))}};
Matrix m = new Matrix(l);
this.l_d.add(m);
int r_index = Integer.parseInt(items[2]);
r_init[r_index]++;
r_sum++;
String[] ws = items[3].split(" ");
Map<String,Double> map = new HashMap<>();
for (String w : ws){
this.words.add(w);
map.put(w, (map.get(w)==null?1:map.get(w)+1));//ๆ ธๅฟไปฃ็ ๅฐฑ่ฟไธๆฎต
}
this.c_w_d.add(map);
}
this.doc_num = this.c_w_d.size();
// ่ฎก็ฎๅๅง็p(r|alpha)
this.p_r_alpha = new double[this.region_num];
for (int r = 0;r < this.region_num;r++){
this.p_r_alpha[r] = r_init[r] / r_sum;
}
// ่ฎก็ฎๅๅง็p(r|alpha) End
// ่ฏปๅๅบๅ็ๅๅงๅๅธ็ๆๆไธๆนๅทฎไฟกๆฏ
BufferedReader E_reader = new BufferedReader(new FileReader(rE_path));
String E_line = null;
while((E_line=E_reader.readLine())!=null) {
String[] items = E_line.split(",");
double[][] e = {{Double.parseDouble(items[0]),Double.parseDouble(items[1])}};
Matrix m = new Matrix(e);
this.r_E.add(m);
}
BufferedReader D_reader = new BufferedReader(new FileReader(rD_path));
String D_line = null;
while((D_line=D_reader.readLine())!=null){
String[] items = D_line.split(",");
String[] i1 = items[0].split(" ");
String[] i2 = items[1].split(" ");
double[][] d = {{Double.parseDouble(i1[0].substring(1)),Double.parseDouble(i1[1].substring(0,i1[1].length()-1))},{Double.parseDouble(i2[0].substring(1)),Double.parseDouble(i2[1].substring(0,i2[1].length()-1))}};
Matrix m = new Matrix(d);
this.r_D.add(m);
}
// double[][] Di = {{1,0},{0,1}};
// Matrix d_i = new Matrix(Di);
// for (int rr = 0;rr < this.region_num;rr++){
// this.r_D.add(d_i);
// }
init_model();
return true;
}
catch (Exception e){
e.printStackTrace();
return false;
}
}
private void init_model(){
// ๅๅงๅp(z|r)
this.p_z_r = new double[this.region_num][this.topic_num];
for (int r = 0;r < this.region_num;r++){
double[] zr = new double[this.topic_num];
double zr_sum = 0;
for (int t = 0;t < this.topic_num;t++){
zr[t] = Math.random();
zr_sum += zr[t];
}
for (int z = 0;z < this.topic_num;z++){
this.p_z_r[r][z] = zr[z] / zr_sum;
}
}
// ่ฎก็ฎๆป่ฏๆฐ
this.all_count = 0;
for (int le = 0;le < this.c_w_d.size();le++){
this.all_count += this.c_w_d.get(le).size();
}
// ็ปๆๆกฃไธญๆฏไธช่ฏไธไธชๅๅงๅ็ๆฆ็ๅๅธ,ๅๅงๅp(w|z)
for (int t = 0;t < this.topic_num;t++){
Map<String,Double> map = new HashMap<>();
for (String w : this.words) {
map.put(w,Math.random());
}
this.p_w_z.add(map);
}
this.sigma_wrz = new HashMap[this.topic_num][this.region_num];
}
public void train(int max_iter){
// ่ฟญไปฃๅผๅง
long startTime = System.currentTimeMillis();
for (int epoch = 0;epoch < max_iter;epoch++){
System.out.println("epoch:" + epoch);
this.p_r_dVariable = new double[this.doc_num][this.region_num];
System.out.println("E Step begins starting!");
// ้ๅๆๆกฃ
for (int d = 0;d < this.doc_num;d++){
List<Double> numerator = new ArrayList<>();
for (int r = 0;r < this.region_num;r++){
// ่ฎก็ฎp(wd|r,Variable)
double p_wd_rVariable = 1;
// ้ๅMapไธญ็Keyๅผ๏ผๅณ้ๅๅๆๆกฃ็ๅ่ฏw
Set<Map.Entry<String,Double>> entries = this.c_w_d.get(d).entrySet();
for (Map.Entry<String,Double> entry : entries){
// ่ฎก็ฎp(w|B)
double sum_cwd = 0;
String w = entry.getKey();
for (int d_id = 0;d_id < this.doc_num;d_id++){
if (this.c_w_d.get(d_id).containsKey(w)){
sum_cwd += this.c_w_d.get(d_id).get(w);
}
}
double p_w_B = sum_cwd / this.all_count;
// ่ฎก็ฎp(w|B) End
// ่ฎก็ฎ๏ผsum z in Z๏ผp(w|z)p(z|r)
double sum_pwz_pzr = 0;
for (int t = 0;t < this.topic_num;t++){
sum_pwz_pzr += (this.p_z_r[r][t] * this.p_w_z.get(t).get(w));
}
// ่ฎก็ฎ๏ผsum z in Z๏ผp(w|z)p(z|r) End
// ่ฎก็ฎp(w|r,Variable)
double p_w_rVariable = this.LambdaB * p_w_B + (1 - this.LambdaB) * sum_pwz_pzr;
// ่ฎก็ฎp(w|r,Variable) End
p_wd_rVariable = p_wd_rVariable * Math.pow(p_w_rVariable, this.c_w_d.get(d).get(w)); // ่ฟไน่ฎก็ฎ p(w|r,Varible)็c(w,d)ๆฌกๆน
}
// ่ฎก็ฎp(wd|r,Variable) End
// ่ฎก็ฎp(ld|r,Variable)
Matrix m = this.l_d.get(d).minus(this.r_E.get(r));
// System.out.println(m.get(0,0) + " " + m.get(0,1));
Matrix m1 = m.times(-1);
Matrix m2 = m1.times(this.r_D.get(r).inverse());
// m3็่กๅๅผ่ฟๅคงๆ่ฟๅฐ
// Math.expๆ ๆณ่ฎก็ฎ
Matrix m3 = m2.times(m.transpose());
// System.out.println(m3.det());
// System.out.println(Math.exp(m3.det()));
double p_ld_rVariable = Math.exp(m3.det() / 2) / (2 * Math.PI * Math.sqrt(Math.abs(this.r_D.get(r).det())));
// ่ฎก็ฎp(ld|r,Variable) End
// ่ฎก็ฎ p(wd,ld|r,Variable) = p(ld|r,Variable) * p(wd|r,Variable)
double p_wdld_rVariable = p_wd_rVariable * p_ld_rVariable;
// ่ฎก็ฎ p(wd,ld|r,Variable) = p(ld|r,Variable) * p(wd|r,Variable) End
// ่ฎก็ฎๅๅญp(r|alpha) * p(wd,ld|r,Variable)
numerator.add(this.p_r_alpha[r] * p_wdld_rVariable);
}
// ่ฎก็ฎๅๅญ End
// ่ฎก็ฎๅๆฏ
double denominator = 0;
for (int i = 0;i<numerator.size();i++){
denominator += numerator.get(i);
}
// ่ฎก็ฎๅๆฏ End
// ่ฎก็ฎp(r|d,Variable)
for (int rr = 0;rr < this.region_num;rr++){
this.p_r_dVariable[d][rr] = numerator.get(rr) / denominator;
}
}
// ้ๅๆๆกฃ,่ฎก็ฎp(r|d,Variable) End
System.out.println("E Step End!");
System.out.println("M Step begins starting!");
for (int r_id = 0;r_id < this.region_num;r_id++){
double r_alpha_numerator = 0;
for (int prd_id = 0;prd_id < this.p_r_dVariable.length;prd_id++){
r_alpha_numerator += this.p_r_dVariable[prd_id][r_id];
}
this.p_r_alpha[r_id] = r_alpha_numerator / this.doc_num;
double[][] Ezero = {{0,0}};
double[][] Dzero = {{0,0},{0,0}};
double[][] j = {{1e-4,0},{0,1e-4}};
Matrix jm = new Matrix(j);
Matrix E_numerator = new Matrix(Ezero);
double denominator = 0;
Matrix D_numerator = new Matrix(Dzero);
for (int d_id = 0;d_id < this.doc_num;d_id++){
E_numerator = E_numerator.plus(this.l_d.get(d_id).times(this.p_r_dVariable[d_id][r_id]));
Matrix m = this.l_d.get(d_id).minus(this.r_E.get(r_id));
Matrix m1 = m.transpose().times(m);
Matrix m2 = m1.times(this.p_r_dVariable[d_id][r_id]);
D_numerator = D_numerator.plus(m2);
denominator = denominator + this.p_r_dVariable[d_id][r_id];
}
D_numerator = D_numerator.plus(jm);
System.out.println("E and D");
System.out.println(E_numerator.times(1/denominator).get(0,0) + " " + E_numerator.times(1/denominator).get(0,1));
System.out.println(D_numerator.times(1/denominator).get(0,0) + " " + D_numerator.times(1/denominator).get(0,1));
System.out.println(D_numerator.times(1/denominator).get(1,0) + " " + D_numerator.times(1/denominator).get(1,1));
this.r_E.set(r_id,E_numerator.times(1/denominator));
this.r_D.set(r_id,D_numerator.times(1/denominator));
}
System.out.println("M Step End!");
System.out.println("Second EM algorithm is starting!");
for (int se_epoch = 0;se_epoch < max_iter;se_epoch++){
// E Step
// ่ฎก็ฎsigma(w,r,z),ๆฑ่งฃp(z|r)ๅp(w|z)
for (int se_z = 0;se_z < this.topic_num;se_z++){
for (int se_r = 0;se_r < this.region_num;se_r++){
Map<String,Double> map = new HashMap<>();
for (String se_w:this.words) {
double se_numerator = (1 - this.LambdaB) * this.p_w_z.get(se_z).get(se_w) * this.p_z_r[se_r][se_z];
// ่ฎก็ฎp(w|B)
double sum_cwd = 0;
for (int d = 0;d < this.doc_num;d++){
if (this.c_w_d.get(d).containsKey(se_w)) {
sum_cwd += this.c_w_d.get(d).get(se_w);
}
}
double se_p_w_B = sum_cwd / this.all_count;
// ่ฎก็ฎp(w|B) End
// ่ฎก็ฎ๏ผsum z in Z๏ผp(w|z)p(z|r)
double se_sum_pwz_pzr = 0;
for (int r = 0;r < this.region_num;r++){
se_sum_pwz_pzr += (this.p_z_r[r][se_z] * this.p_w_z.get(se_z).get(se_w));
}
// ่ฎก็ฎ๏ผsum z in Z๏ผp(w|z)p(z|r) End
double se_denominator = this.LambdaB * se_p_w_B + (1 - this.LambdaB) * se_sum_pwz_pzr;
map.put(se_w,se_numerator / se_denominator) ;
}
this.sigma_wrz[se_z][se_r] = map;
}
}
// E Step End
// M Step
// ่ฎก็ฎp(z|r)
for (int r = 0;r < this.region_num;r++){
double[] pzr_numerator = new double[this.topic_num];
double pzr_denominator = 0;
for (int z = 0;z < this.topic_num;z++){
double _numerator = 0;
for (String _w:this.words) {
for (int d = 0;d < this.doc_num;d++){
if (this.c_w_d.get(d).containsKey(_w)){
_numerator += (this.c_w_d.get(d).get(_w) * this.p_r_dVariable[d][r] * this.sigma_wrz[z][r].get(_w));
}
}
}
pzr_numerator[z] = _numerator;
pzr_denominator += _numerator;
}
for (int zz = 0;zz < this.topic_num;zz++){
this.p_z_r[r][zz] = pzr_numerator[zz] / pzr_denominator;
}
}
// ่ฎก็ฎp(z|r) End
// ่ฎก็ฎp(w|z)
for (int z = 0;z < this.topic_num;z++){
Map<String,Double> pwz_numerator = new HashMap<>();
double pwz_denominator = 0;
for (String w:this.words){
double _numerator = 0;
for (int d = 0;d < this.doc_num;d++){
for (int r = 0;r < this.region_num;r++){
if (this.c_w_d.get(d).containsKey(w)){
_numerator += this.c_w_d.get(d).get(w) * this.p_r_dVariable[d][r] * this.sigma_wrz[z][r].get(w);
}
}
}
pwz_numerator.put(w,_numerator);
pwz_denominator += _numerator;
}
for (String _w:this.words){
this.p_w_z.get(z).put(_w,pwz_numerator.get(_w) / pwz_denominator);
}
}
// ่ฎก็ฎp(w|z) End
// M Step End
}
System.out.println("Second EM algorithm End!");
long endTime = System.currentTimeMillis();
System.out.println("iter " + epoch + " costs time: " + (endTime - startTime) + "ms");
}
calculate_result();
}
// ไฟๅญ่ฎก็ฎ็็ปๆ
public void calculate_result(){
this.p_z_lVariable = new double[this.doc_num][this.topic_num];
// ่ฎก็ฎp(z|l,Variable)
for (int d = 0;d < this.doc_num;d++){
for (int t = 0;t < this.topic_num;t++){
double pz = 0;
for (int r = 0;r < this.region_num;r++){
// ่ฎก็ฎp(l|r,Variable)
Matrix m = this.l_d.get(d).minus(this.r_E.get(r));
Matrix m1 = m.times(-1);
Matrix m2 = m1.times(this.r_D.get(r).inverse());
// m3็่กๅๅผ่ฟๅคงๆ่ฟๅฐ
// Math.expๆ ๆณ่ฎก็ฎ
Matrix m3 = m2.times(m.transpose());
double p_l_rVariable = Math.exp(m3.det() / 2) / (2 * Math.PI * Math.sqrt(Math.abs(this.r_D.get(r).det())));
// ่ฎก็ฎp(l|r,Variable) End
pz += p_l_rVariable * this.p_z_r[r][t] * this.p_r_alpha[r];
}
this.p_z_lVariable[d][t] = pz;
}
}
}
// ่พๅบๆฏไธชๆๆกฃๅฏนๅบ็ไธป้ขไฟกๆฏ
public void print_document_topic(String outputPath){
int[] pzd = new int[this.doc_num];
for (int d = 0;d < this.doc_num;d++){
int maxIndex = 0;
double max = 0;
for (int i = 0;i < this.p_z_lVariable[d].length;i++){
System.out.println(p_z_lVariable[d][i]);
if (this.p_z_lVariable[d][i] > max) {
max = this.p_z_lVariable[d][i];
maxIndex = i;
}
}
System.out.println("Document " + d + " Topic Id is :" + maxIndex);
pzd[d] = maxIndex;
}
try {
BufferedReader csvreader = new BufferedReader(new FileReader(this.inputPath));
String line = null;
int index = 0;
while((line=csvreader.readLine())!=null){
String[] items = line.split(",");//CSVๆ ผๅผๆไปถไธบ้ๅทๅ้็ฌฆๆไปถ๏ผ่ฟ้ๆ นๆฎ้ๅทๅๅ
String lat = items[0].substring(2);
String lon = items[1].substring(0,items[1].length()-2);
String ws = items[3];
int topic = pzd[index];
String writeItem = lat + "," + lon + "," + ws + "," + topic;
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputPath + ".txt",true)));
out.write(writeItem + "\r\n"); // \r\nๅณไธบๆข่ก
out.close();
index++;
}
}catch (Exception e){
e.printStackTrace();
}
}
// ่พๅบไธป้ข็ๅๅ ๅ
ณ้ฎ่ฏ
public void TopicWords(String outputPath,int num){
for (int t = 0;t < this.topic_num;t++){
String writeItem = "";
try {
// Map ๆValue่ฟ่กๆๅบ๏ผ้ๅบ๏ผ
List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(this.p_w_z.get(t).entrySet());
list.sort(new Comparator<Map.Entry<String, Double>>() {
@Override
public int compare(Map.Entry<String, Double> o1, Map.Entry<String, Double> o2) {
return o2.getValue().compareTo(o1.getValue());
}
});
System.out.println("Topic " + t + ":");
writeItem += "Topic " + t + ": \r\n";
for (int i = 0; i < num; i++) {
System.out.println(list.get(i).getKey() + ": " + list.get(i).getValue());
writeItem = writeItem + list.get(i).getKey().toString() + ": " + list.get(i).getValue().toString() + "\r\n";
}
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputPath + ".txt",true)));
out.write(writeItem + "\r\n"); // \r\nๅณไธบๆข่ก
out.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
}
| true
|
e9dea1b77b308b6e48e22072e8818bae4099c70a
|
Java
|
Aosamesan/boolean-calculator
|
/src/main/java/com/aosamesan/model/operator/Operator.java
|
UTF-8
| 341
| 2.328125
| 2
|
[] |
no_license
|
package com.aosamesan.model.operator;
import com.aosamesan.model.ExpressionToken;
import com.aosamesan.model.ExpressionTokenType;
public interface Operator<T> extends ExpressionToken {
T getOperator();
OperatorType getOperatorType();
default ExpressionTokenType getType() {
return ExpressionTokenType.OPERATOR;
}
}
| true
|
7b0606887e0a1ae4c848c6175b52586054cc98ae
|
Java
|
srayas/NGPTrackerBE
|
/src/main/java/net/javaguides/NGPTracker/controller/EmployeeController.java
|
UTF-8
| 3,935
| 2.375
| 2
|
[] |
no_license
|
package net.javaguides.NGPTracker.controller;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
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.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import net.javaguides.NGPTracker.exceptions.ResourcesNotFoundException;
import net.javaguides.NGPTracker.model.Employee;
import net.javaguides.NGPTracker.repository.EmployeeRepository;
@RestController
@RequestMapping("/api/v1/")
//@RequestMapping(value = "/api/v1/", method = {RequestMethod.GET, RequestMethod.POST})
public class EmployeeController {
@Autowired
private EmployeeRepository employeeRepository;
//to find the email id exist or not
//get all list of employee
@CrossOrigin(origins="http://localhost:4200")
@GetMapping("/employees")
public List<Employee> getAllEmployees() {
return employeeRepository.findAll();
}
// create employee rest api
@CrossOrigin(origins="http://localhost:4200")
@PostMapping("/employees")
public Employee createEmployee(@RequestBody Employee employee) {
String tempEmailId = employee.getEmailId();
Employee employeeEmail = employeeRepository.findByEmailId(tempEmailId);
if(employeeEmail !=null) {
throw new ResourcesNotFoundException(" The emailid :"+ tempEmailId+" is already exist");
}
return employeeRepository.save(employee);
}
//get employee by id rest api
@CrossOrigin(origins="http://localhost:4200")
@GetMapping("/employees/{id}")
public ResponseEntity<Employee> getEmployeeById(@PathVariable Long id) {
Employee employee = employeeRepository.findById(id).orElseThrow(() -> new ResourcesNotFoundException("Employee not exist with id :"+ id));
return ResponseEntity.ok(employee);
}
//Update Rest api
@CrossOrigin(origins="http://localhost:4200")
@PutMapping("/employees/{id}")
public ResponseEntity<Employee> updateEmployee(@PathVariable Long id, @RequestBody Employee employeeDetails){
Employee employee = employeeRepository.findById(id).orElseThrow(() -> new ResourcesNotFoundException("Employee not exist with id :"+ id));
employee.setFirstName(employeeDetails.getFirstName());
employee.setLastName(employeeDetails.getLastName());
employee.setEmailId(employeeDetails.getEmailId());
Employee updatedEmployee = employeeRepository.save(employee);
return ResponseEntity.ok(updatedEmployee);
}
//Delete employee rest API
@DeleteMapping("/employees/{id}")
@CrossOrigin(origins="http://localhost:4200")
public ResponseEntity<Map<String, Boolean>> deleteEmployee(@PathVariable Long id){
Employee employee = employeeRepository.findById(id).orElseThrow(() -> new ResourcesNotFoundException("Employee not exist with id :"+ id));
employeeRepository.delete(employee);
Map<String, Boolean> response = new HashMap<>();
response.put("deleted", Boolean.TRUE);
return ResponseEntity.ok(response);
}
@PostMapping("/employees/login")
@CrossOrigin(origins="http://localhost:4200")
public Employee loginEmployee(@RequestBody Employee employee) {
String tempEmailId = employee.getEmailId();
Employee employeeEmail = employeeRepository.findByEmailId(tempEmailId);
if(employeeEmail !=null) {
return employeeRepository.findByEmailId(tempEmailId);
}
throw new ResourcesNotFoundException(" The emailid :"+ tempEmailId+" is doesn't exist");
}
}
| true
|
137bb521ea6bead83f3cd11d1e4deecfbb559880
|
Java
|
kaizhangzhang/spring-boot-demo
|
/akka/Greeter.java
|
UTF-8
| 685
| 2.90625
| 3
|
[] |
no_license
|
package com.example.springbootdemo.akka;
import akka.actor.UntypedAbstractActor;
/**
* @author kai.zhang
* @description ๆๆๅผ็actor
* @since 2018/10/23
*/
public class Greeter extends UntypedAbstractActor {
String greeting = "";
@Override
public void onReceive(Object message) throws Throwable {
if (message instanceof WhoToGreet) {
greeting = "hello " + ((WhoToGreet)message).who;
} else if (message instanceof Greet) {
//ๅ้ๆๅผๆถๆฏ็ป่ฟไธชactor็actor
getSender().tell(new Greeting(greeting), getSelf());
} else {
unhandled(message);
}
}
}
| true
|
58d07b27f38baf94ee2d67cf6b0f1267c937e811
|
Java
|
kimngan120697/POM_NGANVTK_BANKGURU
|
/actions/pageObjects/EditAccountPageObject.java
|
UTF-8
| 262
| 1.914063
| 2
|
[] |
no_license
|
package pageObjects;
import org.openqa.selenium.WebDriver;
import commons.AbstractPage;
public class EditAccountPageObject extends AbstractPage {
WebDriver driver;
public EditAccountPageObject(WebDriver _driver) {
this.driver= _driver;
}
}
| true
|
6d73962b3d2aec281a782a6fd861d46de078f447
|
Java
|
Zpure/foreign-trade
|
/foreign-trade-user-acc/src/main/java/com/zcpure/foreign/trade/feign/user/CustomerMsgFeign.java
|
UTF-8
| 961
| 1.71875
| 2
|
[] |
no_license
|
package com.zcpure.foreign.trade.feign.user;
import com.zcpure.foreign.trade.WebJsonBean;
import com.zcpure.foreign.trade.command.user.CustomerMsgAddCommand;
import com.zcpure.foreign.trade.command.user.CustomerMsgQueryCommand;
import com.zcpure.foreign.trade.dto.goods.GoodsDTO;
import com.zcpure.foreign.trade.dto.user.CustomerMsgDTO;
import com.zcpure.foreign.trade.utils.page.PageBean;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author ethan
* @create_time 2018/10/22 13:43
*/
@FeignClient(name = "foreign-trade-user")
public interface CustomerMsgFeign {
@PostMapping("/api/customer/msg/page")
WebJsonBean<PageBean<CustomerMsgDTO>> queryByPage(@RequestBody CustomerMsgQueryCommand command);
@PostMapping("/api/customer/msg/add")
WebJsonBean<GoodsDTO> add(@RequestBody CustomerMsgAddCommand command);
}
| true
|
36d8699f19263a6592cf8c11e91720b3bc11208c
|
Java
|
windyer39/postermaker-1
|
/app/src/main/java/com/ashu/postermaker/adapters/UsersAdapter.java
|
UTF-8
| 3,499
| 1.992188
| 2
|
[] |
no_license
|
package com.ashu.postermaker.adapters;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.android.volley.toolbox.ImageLoader;
import com.ashu.postermaker.R;
import com.ashu.postermaker.activities.EditImage;
import com.ashu.postermaker.interfaces.LayersListner;
import com.ashu.postermaker.model_classes.Users;
import com.ashu.postermaker.universal.AppController;
import com.ashu.postermaker.view_holders.UsersViewHolder;
import com.squareup.picasso.Picasso;
import java.util.List;
import static com.ashu.postermaker.R.drawable.ic_remove_red_eye_black_24dp;
public class UsersAdapter extends RecyclerView.Adapter<UsersViewHolder> {
private Context context;
private LayoutInflater inflater;
private List<Users> data;
private UsersViewHolder usersViewHolder;
private Users current;
private ImageLoader imageLoader;
private LayersListner layersListner;
public UsersAdapter(Context context, List<Users> data, LayersListner layersListner) {
this.context = context;
this.data = data;
this.inflater = LayoutInflater.from(context);
this.layersListner = layersListner;
}
@NonNull
@Override
public UsersViewHolder onCreateViewHolder(@NonNull ViewGroup viewGroup, int i) {
View view = inflater.inflate(R.layout.item_layers, viewGroup, false);
usersViewHolder = new UsersViewHolder(view);
return usersViewHolder;
}
@Override
public void onBindViewHolder(@NonNull final UsersViewHolder usersViewHolder, final int i) {
current = data.get(i);
String name = current.getCat_name();
String type = current.getCat_id();
if (type.equalsIgnoreCase("image")) {
Picasso.get().load(name).into(usersViewHolder.iv_icon);
usersViewHolder.tv_heading.setVisibility(View.GONE);
usersViewHolder.iv_icon.setVisibility(View.VISIBLE);
} else {
usersViewHolder.tv_heading.setText(name);
usersViewHolder.tv_heading.setVisibility(View.VISIBLE);
usersViewHolder.iv_icon.setVisibility(View.GONE);
}
final int pos = usersViewHolder.getAdapterPosition();
usersViewHolder.rel_item.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
layersListner.clickOnLayer(pos);
if (usersViewHolder.iv_image.getVisibility() == View.VISIBLE) {
usersViewHolder.iv_image_hidden.setVisibility(View.VISIBLE);
usersViewHolder.iv_image.setVisibility(View.GONE);
} else {
usersViewHolder.iv_image_hidden.setVisibility(View.GONE);
usersViewHolder.iv_image.setVisibility(View.VISIBLE);
}
// usersViewHolder.iv_image.setImageDrawable(context.getResources().getDrawable(ic_remove_red_eye_black_24dp));
// usersViewHolder.iv_image.setImageDrawable(ic_remove_red_eye_black_24dp);
// Toast.makeText(context, "item cliecked " + i, Toast.LENGTH_SHORT).show();
}
});
}
@Override
public int getItemCount() {
return data.size();
}
}
| true
|
0f72c8d664899082212b2612690184086e905f28
|
Java
|
codimiracle/user-middleware
|
/src/main/java/com/codimiracle/web/middleware/user/service/UserService.java
|
UTF-8
| 505
| 1.8125
| 2
|
[] |
no_license
|
package com.codimiracle.web.middleware.user.service;
import com.codimiracle.web.middleware.user.pojo.po.UserMetadata;
import com.codimiracle.web.middleware.user.pojo.vo.SocialUserVO;
import com.codimiracle.web.middleware.user.pojo.vo.UserMetadataVO;
import com.codimiracle.web.mybatis.contract.support.vo.Service;
public interface UserService extends Service<String, UserMetadata, UserMetadataVO> {
SocialUserVO findSocialUserById(String userId);
UserMetadata findByUsername(String username);
}
| true
|
63a6fed44f2626fbcfeaeb73a0b5c7ce24616eb3
|
Java
|
moutainhigh/xmas
|
/xmassystem/src/main/java/com/srnpr/xmassystem/plusconfig/PlusConfigBlactList.java
|
UTF-8
| 341
| 1.742188
| 2
|
[] |
no_license
|
package com.srnpr.xmassystem.plusconfig;
import com.srnpr.xmassystem.enumer.EKvSchema;
import com.srnpr.xmassystem.modelproduct.PlusModelBlackList;
public class PlusConfigBlactList extends ConfigTop {
public EKvSchema getSchema() {
return EKvSchema.Black;
}
public Class<?> getPlusClass() {
return PlusModelBlackList.class;
}
}
| true
|
74a8350ebb341c6b07dc311c9da7f8b9001437eb
|
Java
|
markkim976/ticket_test
|
/test_ticket/src/main/java/com/example/ticket_test/service/member/MemberServiceImpl.java
|
UTF-8
| 1,459
| 2.265625
| 2
|
[] |
no_license
|
package com.example.ticket_test.service.member;
import java.util.List;
import javax.inject.Inject;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Service;
import com.example.ticket_test.model.member.dao.MemberDAO;
import com.example.ticket_test.model.member.dto.MemberDTO;
@Service
public class MemberServiceImpl implements MemberService {
@Inject
MemberDAO memberDao;
@Override
public boolean loginCheck(MemberDTO dto, HttpSession session) {
System.out.println("๋ก๊ทธ์ธ ์๋น์ค ํธ์ถ");
boolean result = memberDao.loginCheck(dto);
if(result) {
session.setAttribute("userid", dto.getUserid());
session.setAttribute("name", dto.getName());
}
System.out.println("๋ก๊ทธ์ธ ์๋น์ค ๋ฆฌํด");
System.out.println(dto.getName());
return result;
}
@Override
public MemberDTO viewMember(String userid) {
return memberDao.viewMember(userid);
}
@Override
public List<MemberDTO> list() {
return memberDao.list();
}
@Override
public void insertMember(MemberDTO dto) {
memberDao.insertMember(dto);
}
@Override
public boolean checkPw(String userid, String passwd) {
return memberDao.checkPw(userid, passwd);
}
@Override
public void updateMember(MemberDTO dto) {
memberDao.updateMember(dto);
}
@Override
public void deleteMember(String userid) {
memberDao.deleteMember(userid);
}
@Override
public void logout(HttpSession session) {
session.invalidate();
}
}
| true
|
51eef39a25b46b3fbfcda48cf8f9c41b462ed1b0
|
Java
|
jtap60/com.estr
|
/src/com/estrongs/fs/impl/l/b.java
|
UTF-8
| 1,617
| 1.960938
| 2
|
[] |
no_license
|
package com.estrongs.fs.impl.l;
import com.estrongs.fs.a;
import com.estrongs.fs.w;
import java.io.File;
public class b
extends a
{
protected String a;
private File b;
private long c;
private int d;
private int e;
public b(String paramString1, String paramString2, String paramString3, String paramString4, long paramLong1, long paramLong2, int paramInt1, int paramInt2)
{
super(paramString2, paramString3);
type = w.b;
a = paramString1;
size = paramLong1;
lastModified = paramLong2;
d = paramInt1;
e = paramInt2;
name = paramString4;
}
private void d()
{
if (b == null) {
b = new File(absolutePath);
}
}
public long a()
{
return c;
}
public void a(long paramLong)
{
c = paramLong;
}
public int b()
{
return d;
}
public int c()
{
return e;
}
protected w doGetFileType()
{
return type;
}
public String getPath()
{
return path;
}
public long lastModified()
{
if (lastModified <= 0L)
{
d();
lastModified = b.lastModified();
}
return lastModified;
}
public long length()
{
if (size <= 0L)
{
d();
size = b.length();
}
return size;
}
public void setName(String paramString)
{
if (name != null)
{
String str = name;
absolutePath = (absolutePath.substring(0, absolutePath.lastIndexOf(str)) + paramString);
}
name = paramString;
}
}
/* Location:
* Qualified Name: com.estrongs.fs.impl.l.b
* Java Class Version: 6 (50.0)
* JD-Core Version: 0.7.1
*/
| true
|
e0e15a3e47411a718fa58fa75fe45e3090de3cca
|
Java
|
soooban/RestDoc
|
/RestDocBeanValidation/src/main/java/cn/willingxyz/restdoc/beanvalidation/NegativeOrZeroPostProcessor.java
|
UTF-8
| 981
| 2.390625
| 2
|
[
"Apache-2.0"
] |
permissive
|
package cn.willingxyz.restdoc.beanvalidation;
import cn.willingxyz.restdoc.core.models.PropertyModel;
import cn.willingxyz.restdoc.core.parse.postprocessor.IPropertyPostProcessor;
import cn.willingxyz.restdoc.core.parse.utils.TextUtils;
import com.google.auto.service.AutoService;
import javax.validation.constraints.NegativeOrZero;
/**
* javax.validation.constraints.NegativeOrZero
*/
@AutoService(IPropertyPostProcessor.class)
public class NegativeOrZeroPostProcessor extends AbstractBeanValidationPropertyPostProcessor {
@Override
public PropertyModel postProcessInternal(PropertyModel propertyModel) {
NegativeOrZero negativeAnno = propertyModel.getPropertyItem().getAnnotation(NegativeOrZero.class);
if (negativeAnno == null) return propertyModel;
propertyModel.setDescription(TextUtils.combine(
propertyModel.getDescription(),
" (ๅผๅช่ฝไธบ่ดๆฐๆ0)"
));
return propertyModel;
}
}
| true
|
4f580676cc223f561a93a9aa8e741deb3fa5f49d
|
Java
|
flyJenkins/RepoAnalysis
|
/RepoAnalysisLib/src/main/java/org/flyJenkins/analysis/strategy/JAVASCRIPTAnalysisStrategy.java
|
UTF-8
| 948
| 2.015625
| 2
|
[] |
no_license
|
package org.flyJenkins.analysis.strategy;
import org.flyJenkins.analysis.model.GitHubRepoCmd;
import org.flyJenkins.analysis.model.ProjectDto;
import org.flyJenkins.analysis.model.SearchCodeDto;
import org.flyJenkins.analysis.service.GitHubApiManager;
public class JAVASCRIPTAnalysisStrategy implements LanguageAnalysisManager {
private GitHubApiManager gitHubApiManager;
public void setGitHubApiManager(GitHubApiManager gitHubApiManager) {
this.gitHubApiManager = gitHubApiManager;
}
@Override
public void getGitAnalysisInfo(GitHubRepoCmd gitHubRepoCmd, ProjectDto projectDto) {
// Project node.js์ธ์ง ์ฒดํฌ
gitHubRepoCmd.setQuery("version");
gitHubRepoCmd.setLanguage("json");
SearchCodeDto searchCodeDto = gitHubApiManager.getSearchFileCode(gitHubRepoCmd);
if (searchCodeDto.getTotal_count() > 0) {
projectDto.setAnalysisChance("Y");
projectDto.setProjectType("node.js");
}
}
}
| true
|
262d7fd12bbaee552cf68709041db1e085d7d0da
|
Java
|
namphho/AndroidDagger
|
/app/src/main/java/com/hnam/androiddagger/di/ChatComponent/ChatModule.java
|
UTF-8
| 453
| 1.78125
| 2
|
[] |
no_license
|
package com.hnam.androiddagger.di.ChatComponent;
import android.content.Context;
import com.hnam.androiddagger.database.ChatService;
import com.hnam.androiddagger.database.DBService;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Created by nampham on 12/25/18.
*/
@Module
public class ChatModule {
@Provides
@ChatScope
ChatService provideChatService() {
return new ChatService();
}
}
| true
|
e201a77647103f77656dd05bb7531785436f2a22
|
Java
|
ChaiYe/oaManagerwed
|
/src/main/java/com/officeAuto/ssm/service/impl/ActMarkerServiceImpl.java
|
UTF-8
| 997
| 2.078125
| 2
|
[] |
no_license
|
package com.officeAuto.ssm.service.impl;
import com.officeAuto.ssm.dao.system.ActMarkerDao;
import com.officeAuto.ssm.model.Actmarker;
import com.officeAuto.ssm.service.ActMarkerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
@Transactional(rollbackFor = Exception.class)
public class ActMarkerServiceImpl implements ActMarkerService {
@Autowired
private ActMarkerDao actMarkerDao;
@Override
public List<Actmarker> getActivityMarker(Integer actid, Integer size) throws Exception{
if(actid == null)
throw new Exception();
return actMarkerDao.getActivityMarker(actid, size);
}
@Override
public Integer insert(Actmarker actmarker) throws Exception {
if(actmarker == null)
throw new Exception();
return actMarkerDao.insert(actmarker);
}
}
| true
|
6be7eade7077d3038f8e33f963cb66333edf9880
|
Java
|
manzanf/qa-automation-hws
|
/src/main/java/com/playtika/automation/clothes/Coat.java
|
UTF-8
| 1,298
| 3
| 3
|
[] |
no_license
|
package com.playtika.automation.clothes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
class Coat extends Clothes {
private Tissue cover;
private Tissue lining;
private double coverQuantity;
private double liningQuantity;
private static final Logger logger = LoggerFactory.getLogger(Application.class);
Coat(String size, Tissue cover, Tissue lining, double workComplexity, double coverQuantity, double liningQuantity) {
this.size = size;
this.cover = cover;
this.lining = lining;
this.workComplexity = workComplexity;
this.coverQuantity = coverQuantity;
this.liningQuantity = liningQuantity;
}
void sew() {
logger.info("The coat is sewing:");
joinFurAndLining();
addChain();
}
private void addChain() {
logger.info("Chain was added");
}
private void joinFurAndLining() {
logger.info("Fur and lining were joined");
}
BigDecimal calculatePrice() {
BigDecimal price = new BigDecimal((coverQuantity * cover.getValue() + liningQuantity * lining.getValue()) * (1 + workComplexity));
return price;
}
void chooseMatchedBelt() {
logger.info("The matched belt was chosen");
}
}
| true
|
39392c5e289ca0666819424eb4120956feb35060
|
Java
|
mitp0sh/libjaclaff
|
/src/com/mitp0sh/jaclaff/attributes/stackmaptable/IntegerVariableInfo.java
|
UTF-8
| 863
| 2.1875
| 2
|
[] |
no_license
|
package com.mitp0sh.jaclaff.attributes.stackmaptable;
import java.io.DataInputStream;
import java.io.IOException;
import com.mitp0sh.jaclaff.serialization.SerCtx;
public class IntegerVariableInfo extends AbstractVariableInfo
{
public IntegerVariableInfo()
{
setVariable_info_tag(AbstractVariableInfo.VERIFICATION_TYPE_INFO_INTEGER_TAG);
setVariable_info_string_representation("Integer_variable_info");
}
public static IntegerVariableInfo deserialize(DataInputStream dis) throws IOException
{
return new IntegerVariableInfo();
}
public static byte[] serialize(SerCtx ctx, IntegerVariableInfo integerVariableInfo) throws IOException
{
return new byte[]{};
}
}
// The Integer_variable_info type indicates that the location contains the
// verification type int.
// Integer_variable_info {
// u1 tag = ITEM_Integer; /* 1 */
// }
| true
|
d746d11e796fa02d270a672d13bda96046635371
|
Java
|
ang00/spring-all
|
/spring-elasticsearch/src/main/java/com/em/springelasticsearch/entity/User.java
|
UTF-8
| 480
| 1.796875
| 2
|
[] |
no_license
|
package com.em.springelasticsearch.entity;
import lombok.Data;
import org.springframework.data.elasticsearch.annotations.Document;
import java.io.Serializable;
/**
* @Author: zhangyy
* @Email: zhang10092009@hotmail.com
* @Date: 2021/10/11 15:23:19
* @Version: v1.0
* @Modified๏ผ
* @Description:
*/
@Data
@Document(indexName = "users")
public class User implements Serializable {
private String id;
private String username;
private String password;
private Integer age;
}
| true
|
cd956c3061f9921445ffe1b32c3767c3dde25e17
|
Java
|
psyche1981/BreakbackMonkey
|
/core/src/psyche/breakbackmonkey/input/GameInputProcessor.java
|
UTF-8
| 2,157
| 2.40625
| 2
|
[] |
no_license
|
package psyche.breakbackmonkey.input;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.InputAdapter;
public class GameInputProcessor extends InputAdapter
{
public boolean keyDown(int k)
{
if(k == Keys.W)
GameKeys.setKey(GameKeys.W, true);
if(k == Keys.A)
GameKeys.setKey(GameKeys.A, true);
if(k == Keys.S)
GameKeys.setKey(GameKeys.S, true);
if(k == Keys.D)
GameKeys.setKey(GameKeys.D, true);
if(k == Keys.ENTER)
GameKeys.setKey(GameKeys.ENTER, true);
if(k == Keys.SPACE)
GameKeys.setKey(GameKeys.SPACE, true);
if(k == Keys.P)
GameKeys.setKey(GameKeys.P, true);
if(k == Keys.Y)
GameKeys.setKey(GameKeys.Y, true);
if(k == Keys.N)
GameKeys.setKey(GameKeys.N, true);
if(k == Keys.ESCAPE)
GameKeys.setKey(GameKeys.ESCAPE, true);
if(k == Keys.T)
GameKeys.setKey(GameKeys.T, true);
if(k == Keys.UP)
GameKeys.setKey(GameKeys.UP, true);
if(k == Keys.DOWN)
GameKeys.setKey(GameKeys.DOWN, true);
if(k == Keys.LEFT)
GameKeys.setKey(GameKeys.LEFT, true);
if(k == Keys.RIGHT)
GameKeys.setKey(GameKeys.RIGHT, true);
return true;
}
public boolean keyUp(int k)
{
if(k == Keys.W)
GameKeys.setKey(GameKeys.W, false);
if(k == Keys.A)
GameKeys.setKey(GameKeys.A, false);
if(k == Keys.S)
GameKeys.setKey(GameKeys.S, false);
if(k == Keys.D)
GameKeys.setKey(GameKeys.D, false);
if(k == Keys.ENTER)
GameKeys.setKey(GameKeys.ENTER, false);
if(k == Keys.SPACE)
GameKeys.setKey(GameKeys.SPACE, false);
if(k == Keys.P)
GameKeys.setKey(GameKeys.P, false);
if(k == Keys.Y)
GameKeys.setKey(GameKeys.Y, false);
if(k == Keys.N)
GameKeys.setKey(GameKeys.N, false);
if(k == Keys.ESCAPE)
GameKeys.setKey(GameKeys.ESCAPE, false);
if(k == Keys.T)
GameKeys.setKey(GameKeys.T, false);
if(k == Keys.UP)
GameKeys.setKey(GameKeys.UP, false);
if(k == Keys.DOWN)
GameKeys.setKey(GameKeys.DOWN, false);
if(k == Keys.LEFT)
GameKeys.setKey(GameKeys.LEFT, false);
if(k == Keys.RIGHT)
GameKeys.setKey(GameKeys.RIGHT, false);
return true;
}
}
| true
|
ddfefca24f75fb63da613be46e05eb415d60f633
|
Java
|
ssalihi/JavaClass
|
/src/com/Class9/NestedLoop.java
|
UTF-8
| 730
| 3.375
| 3
|
[] |
no_license
|
package com.Class9;
public class NestedLoop {
public static void main (String[] args ) {
// for (initialization; condition; increment/decrement) {
// for nested loop for(initialization; condition; increment/decrement){}
//}
for (int i=0; i<3; i++) {
System.out.println("-----I am outer loop----- " +i);// outer loop
}
for (int a=0; a<3; a++) {// our inner loop always has depedency on outer loop
System.out.println("I am inner loop " +a);// inner loop
}
//
for (int i=0; i<3; i++) {
for (int a=0; a<3; a++) {// our inner loop always has depedency on outer loop
System.out.println("I am inner loop " +a);// inner loop
}
System.out.println("-----I am outer loop----- "+i);// outer loop
}
}
}
| true
|
9f68111d68d89d28b6f7a7d6927c8156a077a89a
|
Java
|
IN4QA/IN4_Testing_FRameWork
|
/IN4RE/src/test/java/baseClasses/LandSubMenu.java
|
UTF-8
| 3,348
| 1.960938
| 2
|
[] |
no_license
|
package baseClasses;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
import driver.DriverScript;
import methods.Frames;
public class LandSubMenu extends DriverScript {
WebDriver iDriver;
public LandSubMenu(WebDriver oDriver)
{
iDriver = oDriver;
PageFactory.initElements(iDriver, this);
}
@FindBy(xpath = "//a[text()='Property List']")
private WebElement propertyList;
public WebElement getPropertyList()
{
return propertyList;
}
@FindBy(xpath= "//a[text()='Land List']")
private WebElement landList;
public WebElement getLandList()
{
return landList;
}
@FindBy(xpath= "//a[text()='Billing']")
private WebElement billing;
public WebElement getBilling()
{
return billing;
}
@FindBy(xpath= "//a[text()='Budget']")
private WebElement budget;
public WebElement getBudget()
{
return budget;
}
@FindBy(xpath= "//a[text()='Approvals']")
private WebElement approvals;
public WebElement getApprovals()
{
return approvals;
}
@FindBy(xpath= "//a[text()='Masters']")
private WebElement masters;
public WebElement getMasters()
{
return masters;
}
@FindBy(xpath= "//a[text()='Search']")
private WebElement search;
public WebElement getSearch()
{
return search;
}
@FindBy(xpath= "//a[text()='Reports']")
private WebElement reports;
public WebElement getReports()
{
return reports;
}
@FindBy(xpath= "//a[text()='Bulk Upload']")
private WebElement bulkUpload;
public WebElement getBulkUpload()
{
return bulkUpload;
}
public boolean clickPropertyList()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getPropertyList());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickLandList()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getLandList());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickBilling()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getBilling());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickBudget()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getBudget());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickApprovals()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getApprovals());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickMasters()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getMasters());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickSearch()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getSearch());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickReports()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getReports());
return true;
} catch(Exception e)
{
return false;
}
}
public boolean clickBulkUpload()
{
try
{
Frames.SubMenuFrame();
appInd.clickObject(landSubMenu.getBulkUpload());
return true;
} catch(Exception e)
{
return false;
}
}
}
| true
|
f0e6b72a2157c4084545496db941dffb5c0fc03b
|
Java
|
andrewexton373/csc-349-project-1
|
/Sorts.java
|
UTF-8
| 4,524
| 3.625
| 4
|
[] |
no_license
|
/*
Andrew Exton - aexton
Jett Moy - jlmoy
October 1st, 2018
ALGORITHMS - Project 1
*/
public class Sorts {
//Sorts the list of N elements contained in arr[0..N-1] using the selection sort algorithm.
public static void selectionSort(int[] arr, int N) {
// FOR every i starting with first and ending with pre-last position of the list
for (int i = 0; i < N - 1; i++) {
int min = arr[i];
int minIdx = i;
// Find the minimum value in list[i .. length] and save its index in minIndex
for (int j = i; j < N; j++) {
if (arr[j] < arr[minIdx]) {
min = arr[j];
minIdx = j;
}
}
// Swap the two elements at minIndex and i positions
int temp = arr[i];
arr[i] = min;
arr[minIdx] = temp;
}
}
// IF the list contains more than one element
// Cut the list into half //This simply means get the midpoint of the list
// Mergesort the first half
// Mergesort the second half
// Merge the two sorted halves into one sorted list
//Sorts the list of N elements contained in arr[0..N-1] using the merge sort algorithm.
public static void mergeSort (int[] list, int N) {
mergeSort(list, 0, N-1);
}
//this method sorts list[first..last] segment
private static void mergeSort (int[] list, int first, int last) {
if (first < last) { //checking if there is more than one element in list[first..last] segment
int middle = (first + last)/2;
mergeSort(list, first, middle);
mergeSort(list, middle+1, last);
mergeSortedHalves (list, first, middle, last); //call a supporting method to merge 2 halves
}
}
//Merges two sorted halves of the array segment arr[left..right]
//Precondition: arr[left..middle] is sorted; arr[(middle+1)..right] is sorted
//Postcondition: arr[left..right] is sorted.
private static void mergeSortedHalves (int[] arr, int left, int middle, int right) {
int count = right - left + 1;
int[] temp = new int[count];
int index1 = left ;
int index2 = middle + 1;
int index = 0;
// While there are elements in the list find the smaller of the two elements and add it to the temporary array
while (index1 <= middle && index2 <= right) {
if (arr[index1] < arr[index2])
temp[index++] = arr[index1++];
else
temp[index++] = arr[index2++];
}
// Fill the temporary array with the rest of the unfinished halves
while (index1 <= middle) {
temp[index++] = arr[index1++];
}
while (index2 <= right) {
temp[index++] = arr[index2++];
}
// Copy temp back to arr
for (int i = 0; i < count; i++, left++) {
arr[left] = temp[i];
}
}
//Sorts the list of N elements contained in arr[0..N-1] using the quick sort algorithm with
//median-of-three pivot and rearrangement of the three elements
public static void quickSort(int[] arr, int N) {
quickSort(arr, 0, N-1);
}
private static void quickSort(int[] arr, int first, int last) {
if (first < last) { // check there's more than one element in the list
setPivotToEnd(arr, first, last);
int pivotIndex = splitList(arr, first, last);
quickSort(arr, first, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, last);
}
}
private static void setPivotToEnd(int[] arr, int left, int right) {
int temp;
int center = right - left;
// Compare leftmost and center elements
// If leftmost is greator than center element, SWAP
if (arr[left] > arr[center]) {
swap(arr, left, center);
}
// Compare leftmost and rightmost elements
// If leftmost is greator than rightmost element, SWAP
if (arr[left] > arr[right]) {
swap(arr, left, right);
}
// Compare center and rightmost elements
// If center is less than rightmost element, SWAP
// Make center greatest and rightmost median of 3 values
if (arr[center] < arr[right]) {
swap(arr, center, right);
}
}
private static int splitList(int[] arr, int left, int right) {
int temp;
int indexL = left; // first
int indexR = right - 1; // second from last
int pivot = arr[right];
while (indexL < indexR) {
if (arr[indexL] < pivot) indexL++;
if (indexR > indexL && arr[indexR] > pivot) indexR--;
if (indexR > indexL) {
swap(arr, indexL, indexR);
indexL++;
indexR--;
}
}
swap(arr, indexL, right);
return indexL;
}
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
| true
|
2a9de5a4c2215888a35de1d76f4ec431098bf520
|
Java
|
kinnikuren/maze
|
/maze/src/tests/ExceptionTest.java
|
UTF-8
| 1,211
| 3.171875
| 3
|
[] |
no_license
|
package tests;
import game.core.positional.Coordinate;
import game.core.positional.Node;
import java.util.*;
import util.ReadOnlyFlatIterator;
import util.View;
import static util.Print.*;
public class ExceptionTest {
public static void main(String[] args) {
Set<Node> nodeSet = new HashSet<Node>();
nodeSet.add(new Node(1,2));
nodeSet.add(new Node(2,2));
nodeSet.add(new Node(3,2));
View<Coordinate> nodeView = new View<Coordinate>(nodeSet);
Coordinate c1 = new Coordinate(2,2);
Coordinate c2 = new Coordinate(-2,2);
print(nodeView.contains(c1));
print(nodeView.contains(c2));
tryRemoving(nodeSet.iterator());
}
public static void tryRemoving(Iterator<? extends Coordinate> itr) {
/*ReadOnlyFlatIterator<Coordinate> rofi =
new ReadOnlyFlatIterator<Coordinate>(itr);
for (rofi = rofi; rofi.hasNext();) {
Coordinate c = rofi.next();
print(c);
rofi.remove(); */
/* try {
rofi.remove();
} catch (UnsupportedOperationException uoe) {
uoe.printStackTrace();
}
} */
}
}
| true
|
22f784ca3fbd497af82ecf25ee2e04761e2ba91a
|
Java
|
roosteracham/quandansb
|
/src/main/java/ๆฐๆฎ็ปๆ/zsf/linkedlist/oneway/Test.java
|
UTF-8
| 795
| 2.78125
| 3
|
[] |
no_license
|
package ๆฐๆฎ็ปๆ.zsf.linkedlist.oneway;
public class Test {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(2);
linkedList.add(5);
linkedList.add(4);
linkedList.add(6);
System.out.println("๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝฤณ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝวฃ๏ฟฝ" + linkedList.length());
System.out.println("huoqu ๏ฟฝฺผ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ " + linkedList.get(2));
for (int i = 0; i < linkedList.length(); i++) {
System.out.println("\t" + linkedList.get(i));
}
linkedList.remove(1);
//linkedList.add(1,20);
System.out.println("๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝฤณ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝวฃ๏ฟฝ" + linkedList.length());
System.out.println("huoqu ๏ฟฝฺผ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ๏ฟฝ " + linkedList.get(2));
for (int i = 0; i < linkedList.length(); i++) {
System.out.println("\t" + linkedList.get(i));
}
}
}
| true
|
3769e0c79fecec4d425c38b80b885b78ff7d031f
|
Java
|
necrotigr/currencyconverter
|
/src/main/java/nl/necrotigr/converter/service/FixedIoSimpleRetriever.java
|
UTF-8
| 1,859
| 2.390625
| 2
|
[] |
no_license
|
package nl.necrotigr.converter.service;
import com.google.api.client.http.*;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.JsonObjectParser;
import com.google.api.client.json.jackson2.JacksonFactory;
import nl.necrotigr.converter.model.Currency;
import nl.necrotigr.converter.model.ExchangeRate;
import nl.necrotigr.converter.model.dto.FixedIoExRateData;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
public class FixedIoSimpleRetriever implements RateRetriever {
public static final String BASE_URL = "http://api.fixer.io/";
static final HttpTransport HTTP_TRANSPORT = new NetHttpTransport();
static final JsonFactory JSON_FACTORY = new JacksonFactory();
@Override
public ExchangeRate getRate(LocalDate date, Currency currency, Currency baseCurrency) {
HttpRequestFactory requestFactory =
HTTP_TRANSPORT.createRequestFactory(request -> request.setParser(new JsonObjectParser(JSON_FACTORY)));
try {
HttpRequest request = requestFactory.buildGetRequest(new GenericUrl(getUrlString(date, baseCurrency)));
FixedIoExRateData jsonData = request.execute().parseAs(FixedIoExRateData.class);
return jsonData.toExchangeRate(currency);
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
private String getUrlString(LocalDate date, Currency base) {
return BASE_URL + date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")) + "?base=" + base.getCode();
}
@Override
public List<ExchangeRate> getRates(LocalDate from, LocalDate to, Currency currency, Currency baseCurrency) {
return null;
}
}
| true
|
72e54cbd935030996488567f7becb8c282f1fe73
|
Java
|
rosoareslv/SED99
|
/java/neo4j/2019/12/BlockEntry.java
|
UTF-8
| 4,225
| 2.5
| 2
|
[] |
no_license
|
/*
* Copyright (c) 2002-2019 "Neo4j,"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.kernel.impl.index.schema;
import org.neo4j.index.internal.gbptree.Layout;
import org.neo4j.io.pagecache.PageCursor;
import static java.lang.String.format;
import static org.neo4j.index.internal.gbptree.DynamicSizeUtil.extractKeySize;
import static org.neo4j.index.internal.gbptree.DynamicSizeUtil.extractValueSize;
import static org.neo4j.index.internal.gbptree.DynamicSizeUtil.getOverhead;
import static org.neo4j.index.internal.gbptree.DynamicSizeUtil.putKeyValueSize;
import static org.neo4j.index.internal.gbptree.DynamicSizeUtil.readKeyValueSize;
/**
* A {@link BlockEntry} is a key-value mapping and the smallest unit in the {@link BlockStorage} and {@link IndexUpdateStorage} hierarchy. Except for being a
* container class for key-value pairs, it also provide static methods for serializing and deserializing {@link BlockEntry} instances and calculating total
* store size of them.
*/
class BlockEntry<KEY,VALUE>
{
private final KEY key;
private final VALUE value;
BlockEntry( KEY key, VALUE value )
{
this.key = key;
this.value = value;
}
KEY key()
{
return key;
}
VALUE value()
{
return value;
}
@Override
public String toString()
{
return format( "[%s=%s]", key, value );
}
static <VALUE, KEY> int entrySize( Layout<KEY,VALUE> layout, KEY key, VALUE value )
{
int keySize = layout.keySize( key );
int valueSize = layout.valueSize( value );
return keySize + valueSize + getOverhead( keySize, valueSize, false );
}
static <VALUE, KEY> int keySize( Layout<KEY,VALUE> layout, KEY key )
{
int keySize = layout.keySize( key );
return keySize + getOverhead( keySize, 0, false );
}
static <KEY, VALUE> BlockEntry<KEY,VALUE> read( PageCursor pageCursor, Layout<KEY,VALUE> layout )
{
KEY key = layout.newKey();
VALUE value = layout.newValue();
read( pageCursor, layout, key, value );
return new BlockEntry<>( key, value );
}
static <KEY, VALUE> void read( PageCursor pageCursor, Layout<KEY,VALUE> layout, KEY key, VALUE value )
{
long entrySize = readKeyValueSize( pageCursor, false );
layout.readKey( pageCursor, key, extractKeySize( entrySize ) );
layout.readValue( pageCursor, value, extractValueSize( entrySize ) );
}
static <KEY, VALUE> void read( PageCursor pageCursor, Layout<KEY,VALUE> layout, KEY key )
{
long entrySize = readKeyValueSize( pageCursor, false );
layout.readKey( pageCursor, key, extractKeySize( entrySize ) );
}
static <KEY, VALUE> void write( PageCursor pageCursor, Layout<KEY,VALUE> layout, BlockEntry<KEY,VALUE> entry )
{
write( pageCursor, layout, entry.key(), entry.value() );
}
static <KEY, VALUE> void write( PageCursor pageCursor, Layout<KEY,VALUE> layout, KEY key, VALUE value )
{
int keySize = layout.keySize( key );
int valueSize = layout.valueSize( value );
putKeyValueSize( pageCursor, keySize, valueSize, false );
layout.writeKey( pageCursor, key );
layout.writeValue( pageCursor, value );
}
static <KEY, VALUE> void write( PageCursor pageCursor, Layout<KEY,VALUE> layout, KEY key )
{
int keySize = layout.keySize( key );
putKeyValueSize( pageCursor, keySize, 0, false );
layout.writeKey( pageCursor, key );
}
}
| true
|
0b637bc23327db101bc93d13f2183488ed7ade84
|
Java
|
scorsi/epitech-jcoinche
|
/client/src/main/java/client/Client.java
|
UTF-8
| 3,025
| 2.65625
| 3
|
[
"Unlicense"
] |
permissive
|
package client;
import client.command.Commands;
import client.command.ICommand;
import client.net.ClientInitializer;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import proto.Message.MessageWrapper;
import proto.Message.MessageChat;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.sql.Timestamp;
public class Client {
private static final int SERVER_PORT = 8000;
public static void main(String[] args) {
Client client = new Client("localhost", SERVER_PORT);
try {
client.run();
}
catch (Exception e) {
System.out.println(e.toString());
}
finally {
if (client.serverChannel != null && client.serverChannel.isOpen())
client.serverChannel.close();
}
}
private Channel serverChannel = null;
private final String host;
private final int port;
private Client(String host, int port) {
this.host = host;
this.port = port;
}
private void sendMsg(String msg) {
this.serverChannel.writeAndFlush(
MessageWrapper.newBuilder()
.setType(MessageWrapper.MessageType.CHAT)
.setChat(MessageChat.newBuilder().setText(msg).build())
.setTimestamp(new Timestamp(System.currentTimeMillis()).getTime())
.setCode(0)
.build()
);
}
private void checkMsg(String msg) {
if (msg.startsWith("/")) {
try {
((ICommand)(Commands.from(msg).newInstance())).run(msg, this.serverChannel);
} catch (Exception e) {
System.out.println("Invalid command");
}
} else {
this.sendMsg(msg);
}
}
private void run() throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap()
.group(group)
.channel(NioSocketChannel.class)
.handler(new ClientInitializer());
this.serverChannel = bootstrap.connect(host, port).sync().channel();
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
boolean running = true;
while (running) {
String str = in.readLine();
if (str.equals("/exit"))
running = false;
else {
this.checkMsg(str);
}
}
}
finally {
if (this.serverChannel != null)
this.serverChannel.closeFuture().sync();
group.shutdownGracefully();
}
}
}
| true
|
7cc98a9fc8a8cd8279d1847b6e8c799e3273f2fb
|
Java
|
oleksiy-sayankin/code-challenges
|
/algorithms/moderate/number-operations/src/main/java/net/javacogito/numberoperations/Main.java
|
UTF-8
| 3,747
| 3.234375
| 3
|
[] |
no_license
|
package net.javacogito.numberoperations;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
public class Main {
private static final int PLUS = 0;
private static final int MINUS = 1;
private static final int TIMES = 2;
private static final int OVERFLOW = 3;
private static final int OPERATION_COUNT = 4;
private static final int NUMBERS_COUNT = 5;
private static final int FAVORITE_NUMBER = 42;
private static boolean isPossibleToReach = false;
public static void main(String[] args) throws IOException {
File file = new File(args[0]);
BufferedReader buffer = new BufferedReader(new FileReader(file));
String inputLine;
while ((inputLine = buffer.readLine()) != null) {
int[] values = parseValues(inputLine);
isPossibleToReach = false;
permute(values, 0);
if(isPossibleToReach){
System.out.println("YES");
} else {
System.out.println("NO");
}
}
}
private static int[] parseValues(String inputLine){
int[] result = new int[NUMBERS_COUNT];
String[] rawData = inputLine.split(" ");
for(int i = 0; i <= NUMBERS_COUNT - 1; i++){
result[i] = Integer.parseInt(rawData[i]);
}
return result;
}
private static void permute(int[] values, int startIndex){
if(isPossibleToReach) {
return;
}
int length = values.length;
if(startIndex == length - 1){
isPossibleToReach = checkAllOperations(values);
return;
}
for(int i = startIndex; i <= length - 1; i++){
permute(values, startIndex + 1);
values = rotate(values, startIndex);
}
}
private static int[] rotate(int[] values, int startIndex){
int length = values.length;
int[] result = Arrays.copyOf(values, length);
int temp = values[startIndex];
for(int i = startIndex; i <= length - 2; i++){
result[i] = result[i + 1];
}
result[length - 1] = temp;
return result;
}
private static boolean checkAllOperations(int[] values){
OperationSets operationSets = new OperationSets();
int result = 0;
for (int[] operationSet : operationSets){
result = calculate(values, operationSet);
if(result == FAVORITE_NUMBER){
return true;
}
}
return false;
}
private static int calculate(int[] values, int[] operationSet){
int result = values[0];
for (int i = 1; i <= OPERATION_COUNT; i++){
result = calculate(result, values[i], operationSet[i - 1]);
}
return result;
}
private static int calculate(int value1, int value2, int operationCode){
switch (operationCode){
case PLUS: return value1 + value2;
case MINUS: return value1 - value2;
case TIMES: return value1 * value2;
}
return 0;
}
private static class OperationSets implements Iterable<int[]>{
private final int[] operationCodes = new int[OPERATION_COUNT];
{operationCodes[0] = -1;}
@Override
public Iterator<int[]> iterator() {
return new Iterator<int[]>() {
@Override
public boolean hasNext() {
return !(operationCodes[0] == TIMES && operationCodes[1] == TIMES && operationCodes[2] == TIMES &&
operationCodes[3] == TIMES);
}
@Override
public int[] next() {
for(int i = 0; i <= OPERATION_COUNT - 1; i++){
operationCodes[i]++;
if(operationCodes[i] == OVERFLOW){
operationCodes[i] = PLUS;
} else {
break;
}
}
return operationCodes;
}
@Override
public void remove() {
}
};
}
}
}
| true
|
d7d9ba3b33097d6f63bbe66047b193b8aff53bfd
|
Java
|
itsbalamurali/test_build
|
/chatak-pay/src/main/java/com/chatak/pay/constants/ChatakPayErrorCode.java
|
UTF-8
| 3,399
| 2.390625
| 2
|
[] |
no_license
|
/**
*
*/
package com.chatak.pay.constants;
/**
* << Add Comments Here >>
*
* @author Girmiti Software
* @date 23-Feb-2015 6:01:59 PM
* @version 1.0
*/
public enum ChatakPayErrorCode {
TXN_0999("Unable to process your request at this moment. Please try again."),
TXN_0998("System is in under maintenance, please contact support team."),
TXN_0997("Invalid request. Please try again."),
TXN_0996("Invalid access. Please contact support team."),
TXN_0995("Payment is cancelled by user"),
TXN_0994("Problem in connecting to host processor, please contact support team."),
TXN_0993("Invalid request. Please try with valid request data."),
TXN_0992("There seems to be a wrong request data. Please try again with valid request."),
TXN_0001("Invalid Transaction Type."),
TXN_0002("Invalid Order Id."),
TXN_0003("Invalid amount."),
TXN_0004("Invalid Card."),
TXN_0005("Invalid address."),
TXN_0006("Invalid callback url."),
TXN_0007("Invalid merchant."),
TXN_0008("Invalid Transaction ID or Transaction already cancelled or refunded"),
TXN_0009("Invalid card expiry."),
TXN_0010("Invalid card type."),
TXN_0011("Invalid session."),
TXN_0012("Duplicate Transaction. Seems same Order Id is being used for another transaction. Please try with different Order Id."),
TXN_0013("Invalid transaction amount"),
TXN_0014("Invalid merchant name"),
TXN_0015("Invalid card security code."),
TXN_0016("Invalid billing data."),
TXN_0017("Invalid billing address1."),
TXN_0018("Invalid billing city."),
TXN_0019("Invalid billing country."),
TXN_0020("Invalid billing state."),
TXN_0021("Invalid billing zip."),
TXN_0022("Invalid billing email."),
TXN_0023("Invalid Transaction reference number."),
TXN_0024("Invalid track2 data"),
TXN_0025("Duplicate Transaction. Seems same Invoice number is being used for another transaction. Please try with different Invoice number."),
TXN_0026("Invalid Transaction Token."),
TXN_0099("Transaction blocked,duplicate Transaction with same card, please try after some time"),
TXN_0100("Approved"),
TXN_0101("Ecommerce purchase is not processed. Please try again."),
TXN_0102("Ecommerce void transaction is not processed. Please try again."),
TXN_0103("Invalid Transaction Id or transaction already refunded "),
TXN_0104("Invalid split transaction data"),
TXN_0105("Invalid split transaction amount"),
TXN_0106("Invalid split reference details"),
TXN_0107("Invalid ShareMode Type."),
TXN_0108("Unable to process split payment with given data, please try again"),
TXN_0109("Invalid split transaction reference number"),
TXN_0110("Invalid Key serial number"),
TXN_0111("Invalid Request With Both Card And Token Details"),
TXN_0112("Invalid Card Token Details"),
TXN_0113("Transaction is in processing state"),
TXN_0114("Invalid merchantId/terminalId"),
TXN_0115("Card not accepted"),
GEN_001("Success"),
GEN_002("Error");
private final String value;
ChatakPayErrorCode(String v) {
value = v;
}
public String value() {
return value;
}
public static ChatakPayErrorCode fromValue(String v) {
for(ChatakPayErrorCode c : ChatakPayErrorCode.values()) {
if(c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}
}
| true
|
daed487e5e6567d5624964070dd22268ea141c82
|
Java
|
mmomtchev/node-gdal-async
|
/deps/libhdf5/hdf5/java/src/hdf/hdf5lib/exceptions/HDF5LowLevelIOException.java
|
UTF-8
| 1,628
| 2.203125
| 2
|
[
"Apache-2.0",
"LicenseRef-scancode-hdf5",
"LicenseRef-scancode-llnl",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the COPYING file, which can be found at the root of the source code *
* distribution tree, or in https://www.hdfgroup.org/licenses. *
* If you do not have access to either file, you may request a copy from *
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
package hdf.hdf5lib.exceptions;
/**
* The class HDF5LibraryException returns errors raised by the HDF5 library.
* <p>
* This sub-class represents HDF-5 major error code <b>H5E_IO</b>
*/
public class HDF5LowLevelIOException extends HDF5LibraryException {
/**
* Constructs an <code>HDF5LowLevelIOException</code> with no specified
* detail message.
*/
public HDF5LowLevelIOException() {
super();
}
/**
* Constructs an <code>HDF5LowLevelIOException</code> with the specified
* detail message.
*
* @param s
* the detail message.
*/
public HDF5LowLevelIOException(String s) {
super(s);
}
}
| true
|
d0ec2b33d4ef2cde9e51b8fb0f5cf3773d2dbd4c
|
Java
|
jgmatos/ReSPA
|
/ReSPA/src/respa/leak/string/exclude/Exclude.java
|
UTF-8
| 466
| 2.1875
| 2
|
[] |
no_license
|
package respa.leak.string.exclude;
import java.math.BigDecimal;
public abstract class Exclude implements Cloneable{
public abstract double getAlphaValue();
public abstract BigDecimal getPreciseAlphaValue();
public abstract boolean valid(String concrete);
public abstract double getLogAlpha();
public abstract double getComplementLogAlpha();
public abstract Exclude makeCopy();
@Override
public Object clone() {
return makeCopy();
}
}
| true
|
6aaa2a0e06af85c3980813642e4553db425f8bfa
|
Java
|
yushouling/design-patterns
|
/bridge/src/main/java/com/ysl/design/bridge/BridgeFrom.java
|
UTF-8
| 185
| 2.15625
| 2
|
[] |
no_license
|
package com.ysl.design.bridge;
/**
* ๆกฅๆฅๆจกๅผๅ
ณ้ฎไปฃ็
*/
public abstract class BridgeFrom {
public BridgeTarget bridgeTarget;
public abstract void from();
}
| true
|
5394ea6b90ff51d34f8f7d9147084047f20b50fc
|
Java
|
kxp128/ydjw
|
/ydjw-modules/ydjw-police/src/main/java/com/ehootu/park/service/ChemicalsInspectionService.java
|
UTF-8
| 1,056
| 1.875
| 2
|
[] |
no_license
|
package com.ehootu.park.service;
import com.ehootu.park.model.ChemicalsInspectionEntity;
import com.ehootu.park.model.PublicInformationEntity;
import java.util.List;
import java.util.Map;
/**
* ๆๅถๆฏๅๅญฆๅๆฃ้ช่กจ
* ๅงๆฏใๆๅถๆฏๅๅญฆๅ ไธ้กนๆฃๆฅ
* @author yinyujun
* @email
* @date 2017-09-26 16:27:31
*/
public interface ChemicalsInspectionService{
int queryTotal(Map<String, Object> map);
void save(ChemicalsInspectionEntity chemicalsInspection);
void update(ChemicalsInspectionEntity chemicalsInspection);
void delete(String id);
void deleteBatch(Integer[] ids);
ChemicalsInspectionEntity queryObject(String id);
List<ChemicalsInspectionEntity> queryList(Map<String, Object> map);
List<ChemicalsInspectionEntity> select(String id);
List<ChemicalsInspectionEntity> selectOne(String dizhibianma);
List<ChemicalsInspectionEntity> selectAddress(String enterprise_address);
void save(ChemicalsInspectionEntity chemicalsInspection, PublicInformationEntity publicInformation, String pageName);
}
| true
|
66c623d6cdc4fc4ca2a465e9704a8ad7045127df
|
Java
|
tactusoft/anexa
|
/hiz/JavaSource/co/com/tactusoft/crm/controller/bo/BillingBO.java
|
UTF-8
| 2,824
| 2.28125
| 2
|
[] |
no_license
|
package co.com.tactusoft.crm.controller.bo;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.LinkedList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import co.com.tactusoft.crm.model.dao.CustomHibernateDao;
import co.com.tactusoft.crm.model.entities.CrmCalcScheme;
import co.com.tactusoft.crm.model.entities.CrmCalcSchemeDetail;
import co.com.tactusoft.crm.model.entities.CrmCalcSchemeResult;
import co.com.tactusoft.crm.model.entities.CrmTerm;
import co.com.tactusoft.crm.model.entities.CrmTermMaterial;
@Service
public class BillingBO implements Serializable {
private static final long serialVersionUID = 1L;
@Autowired
private CustomHibernateDao dao;
public List<CrmCalcSchemeDetail> getCalSchemaActive() {
CrmCalcScheme header = (CrmCalcScheme) dao.find(
"FROM CrmCalcScheme o WHERE o.status = 1").get(0);
return dao
.find("FROM CrmCalcSchemeDetail o WHERE o.crmCalcScheme.id = "
+ header.getId());
}
public List<CrmCalcSchemeResult> execute(String salesOrg, String distrChan,
String codMaterial, BigDecimal price) {
Double result = price.doubleValue();
Double operation = 0d;
List<CrmCalcSchemeResult> returnList = new LinkedList<>();
try {
List<CrmCalcSchemeDetail> list = this.getCalSchemaActive();
System.out.println("Precio: " + price);
returnList.add(new CrmCalcSchemeResult(null, "Precio",
new BigDecimal(result), true, false));
for (CrmCalcSchemeDetail row : list) {
CrmTerm crmTerm = row.getCrmTerm();
if (crmTerm.getSalesOrg().equals(salesOrg)
&& crmTerm.getDistrChan().equals(distrChan)) {
List<CrmTermMaterial> listMaterial = crmTerm
.getCrmTermMaterials();
boolean exists = false;
for (CrmTermMaterial det : listMaterial) {
if (det.getCodMaterial().equals(codMaterial)) {
exists = true;
break;
}
}
if (exists) {
String type = crmTerm.getTypeTerm();
String sign = crmTerm.getSign();
operation = row.getValue().doubleValue();
if (type.equals("I")) {
if (sign.equals("N")) {
operation = operation * -1;
}
} else {
operation = (result * row.getValue().doubleValue()) / 100;
if (sign.equals("N")) {
operation = operation * -1;
}
}
System.out
.println(crmTerm.getName() + ": " + operation);
result = result + operation;
returnList.add(new CrmCalcSchemeResult(crmTerm, crmTerm
.getName(), new BigDecimal(operation), false,
false));
}
}
}
returnList.add(new CrmCalcSchemeResult(null, "Total",
new BigDecimal(result), false, true));
} catch (Exception ex) {
ex.printStackTrace();
}
return returnList;
}
}
| true
|
c03ae392c311e7a9c4dfa031a6e0ad29661e75c2
|
Java
|
AnaisLeseur/projet_app_voyage
|
/02_App_voyage_jsf/src/com/intiformation/DAO/LigneCommandeDAOImpl.java
|
UTF-8
| 9,752
| 2.875
| 3
|
[] |
no_license
|
package com.intiformation.DAO;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.intiformation.modeles.LigneCommande;
/**
* Implรฉmentation concrรจte de la DAO pour 'lignes_commandes'.
* 'lignes_commandes' : table d'association entre un produit et une commande.
* classe qui implemente l'interface ILigneCommandeDAO
*
* @author vincent
*
*/
public class LigneCommandeDAOImpl implements ILigneCommandeDAO {
private PreparedStatement ps = null;
private ResultSet rs = null;
/* ================================================== */
/**
* AJOUTER UNE LIGNE DE COMMANDE
* @param pLigneCommande : ligne de commande ร ajouter
* @return boolean: si ajout ok ou non
*/
@Override
public boolean add(LigneCommande pLigneCommande) {
try {
// prepared statement + requete SQL
ps = this.connexion.prepareStatement("insert into lignes_commandes"
+ "(commande_id, produit_id, quantite_ligne, prix_ligne)"
+ "values (?, ?, ?, ?)");
// passage de params
ps.setInt(1, pLigneCommande.getCommande_id());
ps.setInt(2, pLigneCommande.getProduit_id());
ps.setInt(3, pLigneCommande.getQuantite_ligne());
ps.setDouble(4, pLigneCommande.getPrix_ligne());
// executeUpdate
int verif = ps.executeUpdate();
return (verif == 1);
} catch (SQLException e) {
System.out.println("LigneCommandeDAOImpl : erreur add()");
e.printStackTrace();
}finally {
try {
// fermeture des ressources
ps.close();
}catch (Exception e) {
}// end catch
}// end finally
return false;
}// end add
/* ================================================== */
/**
* MODIFIER UNE LIGNE DE COMMANDE
* @param pLigneCommande : ligne de commande ร modifier
* @return boolean: si modification ok ou non
*/
@Override
public boolean update(LigneCommande pLigneCommande) {
try {
ps = this.connexion.prepareStatement("update lignes_commandes set "
+ "quantite_ligne=?, prix_ligne=? where commande_id=? and produit_id=?") ;
ps.setInt(1, pLigneCommande.getQuantite_ligne());
ps.setDouble(2, pLigneCommande.getPrix_ligne());
ps.setInt(3, pLigneCommande.getCommande_id());
ps.setInt(4, pLigneCommande.getProduit_id());
int verif = ps.executeUpdate();
return (verif == 1);
} catch (SQLException e) {
System.out.println("LigneCommandeDAOImpl : erreur update()");
e.printStackTrace();
}finally {
try {
ps.close();
}catch (Exception e) {
}// end catch
}// end finally
return false;
}// end update
/* ================================================== */
/**
* RECUPERER LA LISTE DE TOUTES LES LIGNES DE COMMANDES
* @return List<LigneCommande> listeligneCommandeBdd : la liste de toutes les lignes de commandes
*
*/
@Override
public List<LigneCommande> getAll() {
try {
ps = this.connexion.prepareStatement("select * from lignes_commandes");
rs = ps.executeQuery();
List<LigneCommande> listeligneCommandeBdd = new ArrayList<>();
LigneCommande ligneCommande = null;
while (rs.next()) {
ligneCommande = new LigneCommande(rs.getInt(1),
rs.getInt(2),
rs.getInt(3),
rs.getDouble(4));
listeligneCommandeBdd.add(ligneCommande);
}// end while
return listeligneCommandeBdd;
} catch (SQLException e) {
System.out.println("Dans LigneCommandeDAOImpl : erreur getAll()");
e.printStackTrace();
}finally {
try {
rs.close();
ps.close();
}catch (Exception e) {
// TODO: handle exception
}// end catch
}// end finally
return null;
}// end getAll
/* ================================================== */
/**
* RECUPERER UNE LIGNE DE COMMANDE
* @param pIdCommande : id de la commande
* @param pIdProduit : id du produit
*
* @return List<LigneCommande> listeligneCommandeByDbleId : liste des lignes de commande avec pIdCommande et pIdProduit
*/
// ERREUR sur le return : devrait รชtre <LigneCommande> car il n'y a qu'une ligne de commande avec pIdCommande et pIdProduit
// ICI return List<LigneCommande> listeligneCommandeByDbleId : composรฉe d'1 seul element <LigneCommande>
@Override
public List<LigneCommande> getByDoubleId(Integer pIdCommande, Integer pIdProduit) {
try {
ps = this.connexion.prepareStatement("select * from lignes_commandes where where commande_id=? and produit_id=?");
ps.setInt(1, pIdCommande);
ps.setInt(2, pIdProduit);
rs = ps.executeQuery();
List<LigneCommande> listeligneCommandeByDbleId = new ArrayList<>();
LigneCommande ligneCommande = null;
while (rs.next()) {
ligneCommande = new LigneCommande(rs.getInt(1),
rs.getInt(2),
rs.getInt(3),
rs.getDouble(4));
listeligneCommandeByDbleId .add(ligneCommande);
}// end while
return listeligneCommandeByDbleId ;
} catch (SQLException e) {
System.out.println("LigneCommandeDAOImpl : erreur getByDoubleId()");
e.printStackTrace();
}finally {
try {
ps.close();
}catch (Exception e) {
// TODO: handle exception
}// end catch
}// end finally
return null;
}// end getByDoubleId
/* ================================================== */
/**
* SUPPRIMER UNE LIGNE DE COMMANDE via ses 2 PK
*
* @param pIdCommande : id de la commande
* @param pIdProduit : id du produit
*
* @return boolean: si la suppression ok ou non
*/
@Override
public boolean deleteDoubleId(Integer pIdCommande, Integer pIdProduit) {
try {
ps = this.connexion.prepareStatement("delete From lignes_commandes where where commande_id=? and produit_id=?");
ps.setInt(1, pIdCommande);
ps.setInt(2, pIdProduit);
int verif = ps.executeUpdate();
return (verif == 1);
} catch (SQLException e) {
System.out.println("LigneCommandeDAOImpl : erreur delete()");
e.printStackTrace();
}finally {
try {
ps.close();
}catch (Exception e) {
// TODO: handle exception
}// end catch
}// end finally
return false;
}// end deleteDoubleId
/* ================================================== */
/**
* RECUPERER LA LISTE DES LIGNES DE COMMANDE ASSOCIEES A UNE COMMANDE
* @param pIdCommande : id de la commande
*
* @return List<LigneCommande> listeligneCommandeByIdCommande : liste des lignes de commande avec pIdCommande
*
*/
@Override
public List<LigneCommande> getByIdCommande(Integer pIdCommande) {
try {
ps = this.connexion.prepareStatement("select * from lignes_commandes where commande_id=?");
ps.setInt(1, pIdCommande);
rs = ps.executeQuery();
List<LigneCommande> listeligneCommandeByIdCommande = new ArrayList<>();
LigneCommande ligneCommande = null;
while (rs.next()) {
ligneCommande = new LigneCommande(rs.getInt(1),
rs.getInt(2),
rs.getInt(3),
rs.getDouble(4));
listeligneCommandeByIdCommande .add(ligneCommande);
}// end while
return listeligneCommandeByIdCommande ;
} catch (SQLException e) {
System.out.println("LigneCommandeDAOImpl : erreur getByIdCommande()");
e.printStackTrace();
}finally {
try {
ps.close();
}catch (Exception e) {
// TODO: handle exception
}// end catch
}// end finally
return null;
}// end getByIdCommande
/* ================================================== */
/**
* RECUPERER LA LISTE DES LIGNES DE COMMANDE "SELECTIONNES" PAR LE CLIENT ( via les produits ajoutรฉs au panier)
* via une vue de la bdd
* ( cette vue permet aussi de rรฉcupรฉrer d'autres infos pour afficher un rรฉcapitulatif complet avant le paiement: lignes de commande, produits...)
*
* @param idClient : id du client => la rรฉcupรฉration des informations se fait a partir de l'id du client
*
* @return List<LigneCommande> listeLignesCommandeDuClient : liste des lignes de commande que le client ร dans son panier via les produits ajoutรฉs
*/
@Override
public List<LigneCommande> findCommandePourCreaAffichage(Integer idClient) {
try {
ps = this.connexion.prepareStatement("select * from vieu_commande_client_clients where id_client=?");
ps.setInt(1, idClient);
rs = ps.executeQuery();
List<LigneCommande> listeLignesCommandeDuClient = new ArrayList<>();
LigneCommande lignecommande = null;
while (rs.next()) {
lignecommande = new LigneCommande(rs.getInt(20), rs.getInt(21), rs.getInt(22), rs.getDouble(23));
listeLignesCommandeDuClient.add(lignecommande);
}//end while
return listeLignesCommandeDuClient;
} catch (SQLException e) {
System.out.println("... Erreur lors de la mรฉthode findCommandePourCreaAffichage() de LigneCommandeDAOImpl ...");
e.printStackTrace();
}finally {
try {
rs.close();
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//end catch
}//end finally
return null;
}// end findCommandePourCreaAffichage
/* ================================================== */
// METH NON UTILISEES
/**
* pour supprimer une ligne de commande : ne peut pas utilisรฉe car besoin de 2 id => Cf meth deleteDoubleId
*/
@Override
public boolean delete(Integer pidLigneCommande) {
return false;
}// end delete
/**
* pour rรฉcupรฉrer une ligne de commande : ne peut pas utilisรฉe car besoin de 2 id => Cf meth getByDoubleId
*/
@Override
public LigneCommande getById(Integer pidLigneCommande) {
// TODO Auto-generated method stub
return null;
}// end getById
}// end class
| true
|
bd8243f7dd664dd2f028bc7d9a134ed972850fc0
|
Java
|
xeostream/Coursea
|
/Application of Binary Tree/HeapImpl.java
|
UTF-8
| 1,588
| 3.3125
| 3
|
[
"MIT"
] |
permissive
|
/*
* 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 ApplicationofBinaryTree;
import java.util.Scanner;
/**
*
* @author Arthur
*/
public class HeapImpl {
public static void addNum(int[] nums, int num, int len) {
int i = len;
for (; i > 0 && num < nums[(i-1)/2]; i = (i-1)/2)
nums[i] = nums[(i-1)/2];
nums[i] = num;
}
public static int deleteMin(int[] nums, int len) {
int num = nums[0];
int i = 0;
int j = 2 * i + 1;
while (j < len) {
if (j+1 < len && nums[j] > nums[j+1])
j++;
if (nums[len] <= nums[j]) break;
nums[i] = nums[j];
i = j;
j = 2 * i + 1;
}
nums[i] = nums[len];
return num;
}
public static void main(String ...args) {
Scanner scan = new Scanner(System.in);
int cnt = scan.nextInt();
while (cnt-- > 0) {
int len = 0;
int count = scan.nextInt();
int[] nums = new int[count];
while (count-- > 0) {
int type = scan.nextInt();
if (type == 1) {
int num = scan.nextInt();
addNum(nums, num, len++);
} else if (type == 2) {
int temp = deleteMin(nums, --len);
System.out.println(temp);
}
}
}
}
}
| true
|
dc0b217bbdb501e18afff83f09b603f85350b7fc
|
Java
|
dffan0829/classnet_test
|
/src/com/classnet/util/upload/UploadException.java
|
UTF-8
| 477
| 2.171875
| 2
|
[] |
no_license
|
package com.classnet.util.upload;
@SuppressWarnings("serial")
public class UploadException extends Exception {
public UploadException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public UploadException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public UploadException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}
| true
|
4681398cfff0b1accd4591068adf470c3a14bcc2
|
Java
|
Alexander12827/iCatch
|
/app/src/main/java/com/icatch/ismartdv2016/View/Fragment/MultiPbPhotoFragment.java
|
UTF-8
| 10,593
| 2
| 2
|
[] |
no_license
|
package com.icatch.ismartdv2016.View.Fragment;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import com.icatch.ismartdv2016.Adapter.MultiPbPhotoWallGridAdapter;
import com.icatch.ismartdv2016.Adapter.MultiPbPhotoWallListAdapter;
import com.icatch.ismartdv2016.BaseItems.MultiPbItemInfo;
import com.icatch.ismartdv2016.Listener.OnStatusChangedListener;
import com.icatch.ismartdv2016.Log.AppLog;
import com.icatch.ismartdv2016.Mode.OperationMode;
import com.icatch.ismartdv2016.Presenter.MultiPbPhotoFragmentPresenter;
import com.icatch.ismartdv2016.R;
import com.icatch.ismartdv2016.View.Interface.MultiPbPhotoFragmentView;
import com.tonicartos.widget.stickygridheaders.StickyGridHeadersGridView;
import java.util.List;
public class MultiPbPhotoFragment extends Fragment implements MultiPbPhotoFragmentView {
private static final String TAG = "MultiPbPhotoFragment";
TextView headerView;
private boolean isCreated = false;
private boolean isVisible = false;
ListView listView;
private OnStatusChangedListener modeChangedListener;
StickyGridHeadersGridView multiPbPhotoGridView;
FrameLayout multiPbPhotoListLayout;
MultiPbPhotoFragmentPresenter presenter;
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
AppLog.d(TAG, "MultiPbPhotoFragment onCreateView");
View view = inflater.inflate(R.layout.fragment_multi_pb_photo, container, false);
this.multiPbPhotoGridView = (StickyGridHeadersGridView) view.findViewById(R.id.multi_pb_photo_grid_view);
this.listView = (ListView) view.findViewById(R.id.multi_pb_photo_list_view);
this.headerView = (TextView) view.findViewById(R.id.photo_wall_header);
this.multiPbPhotoListLayout = (FrameLayout) view.findViewById(R.id.multi_pb_photo_list_layout);
this.presenter = new MultiPbPhotoFragmentPresenter(getActivity());
this.presenter.setView(this);
this.listView.setOnScrollListener(new OnScrollListener() {
public void onScrollStateChanged(AbsListView view, int scrollState) {
int firstVisible = MultiPbPhotoFragment.this.listView.getFirstVisiblePosition();
int lastVisible = MultiPbPhotoFragment.this.listView.getLastVisiblePosition();
AppLog.d(MultiPbPhotoFragment.TAG, "listView onScrollStateChanged firstVisible=" + firstVisible + " lastVisible=" + lastVisible);
if (MultiPbPhotoFragment.this.isVisible) {
MultiPbPhotoFragment.this.presenter.listViewLoadThumbnails(scrollState, firstVisible, (lastVisible - firstVisible) + 1);
}
}
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
if (MultiPbPhotoFragment.this.isVisible) {
MultiPbPhotoFragment.this.presenter.listViewLoadOnceThumbnails(firstVisibleItem, visibleItemCount);
}
}
});
this.multiPbPhotoGridView.setOnScrollListener(new OnScrollListener() {
public void onScrollStateChanged(AbsListView view, int scrollState) {
AppLog.d(MultiPbPhotoFragment.TAG, "11333 view onScrollStateChanged firstVisible=" + view.getFirstVisiblePosition() + " lastVisible=" + view.getLastVisiblePosition());
int firstVisible = MultiPbPhotoFragment.this.multiPbPhotoGridView.getFirstVisiblePosition();
int lastVisible = MultiPbPhotoFragment.this.multiPbPhotoGridView.getLastVisiblePosition();
AppLog.d(MultiPbPhotoFragment.TAG, "11333 onScrollStateChanged firstVisible=" + firstVisible + " lastVisible=" + lastVisible);
if (MultiPbPhotoFragment.this.isVisible) {
MultiPbPhotoFragment.this.presenter.gridViewLoadThumbnails(scrollState, firstVisible, (lastVisible - firstVisible) + 1);
}
}
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
AppLog.d(MultiPbPhotoFragment.TAG, "1122 onScroll firstVisibleItem=" + firstVisibleItem + " visibleItemCount=" + visibleItemCount);
if (MultiPbPhotoFragment.this.isVisible) {
MultiPbPhotoFragment.this.presenter.gridViewLoadOnceThumbnails(firstVisibleItem, visibleItemCount);
}
}
});
this.listView.setOnItemLongClickListener(new OnItemLongClickListener() {
public boolean onItemLongClick(AdapterView<?> adapterView, View view, int position, long id) {
if (MultiPbPhotoFragment.this.isVisible) {
MultiPbPhotoFragment.this.presenter.listViewEnterEditMode(position);
}
return true;
}
});
this.multiPbPhotoGridView.setOnItemLongClickListener(new OnItemLongClickListener() {
public boolean onItemLongClick(AdapterView<?> adapterView, View view, int position, long id) {
MultiPbPhotoFragment.this.presenter.gridViewEnterEditMode(position);
return true;
}
});
this.listView.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
Log.d("1111", "listView.setOnItemClickListener");
MultiPbPhotoFragment.this.presenter.listViewSelectOrCancelOnce(position);
}
});
this.multiPbPhotoGridView.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
Log.d("1111", "multiPbPhotoGridView.setOnItemClickListener");
MultiPbPhotoFragment.this.presenter.gridViewSelectOrCancelOnce(position);
}
});
this.isCreated = true;
return view;
}
public void onResume() {
super.onResume();
AppLog.d(TAG, "start onResume() isVisible=" + this.isVisible + " presenter=" + this.presenter);
if (this.isVisible) {
this.presenter.loadPhotoWall();
}
AppLog.d(TAG, "end onResume");
}
public void onStop() {
AppLog.d(TAG, "start onStop()");
super.onStop();
}
public void onDestroy() {
AppLog.d(TAG, "start onDestroy()");
super.onDestroy();
this.presenter.clealAsytaskList();
this.presenter.emptyFileList();
}
public void changePreviewType() {
AppLog.d(TAG, "start changePreviewType presenter=" + this.presenter);
if (this.presenter != null) {
this.presenter.changePreviewType();
}
}
public void quitEditMode() {
this.presenter.quitEditMode();
}
public void setListViewVisibility(int visibility) {
this.multiPbPhotoListLayout.setVisibility(visibility);
}
public void setGridViewVisibility(int visibility) {
this.multiPbPhotoGridView.setVisibility(visibility);
}
public void setListViewAdapter(MultiPbPhotoWallListAdapter photoWallListAdapter) {
this.listView.setAdapter(photoWallListAdapter);
}
public void setGridViewAdapter(MultiPbPhotoWallGridAdapter photoWallGridAdapter) {
this.multiPbPhotoGridView.setAdapter(photoWallGridAdapter);
}
public void setListViewSelection(int position) {
this.listView.setSelection(position);
}
public void setGridViewSelection(int position) {
this.multiPbPhotoGridView.setSelection(position);
}
public void setListViewHeaderText(String headerText) {
this.headerView.setText(headerText);
}
public View listViewFindViewWithTag(int tag) {
return this.listView.findViewWithTag(Integer.valueOf(tag));
}
public View gridViewFindViewWithTag(int tag) {
return this.multiPbPhotoGridView.findViewWithTag(Integer.valueOf(tag));
}
public void updateGridViewBitmaps(String tag, Bitmap bitmap) {
ImageView imageView = (ImageView) this.multiPbPhotoGridView.findViewWithTag(tag);
if (imageView != null) {
imageView.setImageBitmap(bitmap);
}
}
public void notifyChangeMultiPbMode(OperationMode operationMode) {
if (this.modeChangedListener != null) {
this.modeChangedListener.onEnterEditMode(operationMode);
}
}
public void setPhotoSelectNumText(int selectNum) {
if (this.modeChangedListener != null) {
this.modeChangedListener.onSelectedItemsCountChanged(selectNum);
}
}
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
Log.i("1122", "MultiPbPhotoFragment onConfigurationChanged");
this.presenter.refreshPhotoWall();
}
public void setUserVisibleHint(boolean isVisibleToUser) {
super.setUserVisibleHint(isVisibleToUser);
AppLog.d(TAG, "setUserVisibleHint isVisibleToUser=" + isVisibleToUser);
AppLog.d(TAG, "setUserVisibleHint isCreated=" + this.isCreated);
this.isVisible = isVisibleToUser;
if (!this.isCreated) {
return;
}
if (isVisibleToUser) {
this.presenter.loadPhotoWall();
return;
}
this.presenter.quitEditMode();
this.presenter.clealAsytaskList();
}
public void refreshPhotoWall() {
this.presenter.refreshPhotoWall();
}
public void setOperationListener(OnStatusChangedListener modeChangedListener) {
this.modeChangedListener = modeChangedListener;
}
public void selectOrCancelAll(boolean isSelectAll) {
this.presenter.selectOrCancelAll(isSelectAll);
}
public List<MultiPbItemInfo> getSelectedList() {
return this.presenter.getSelectedList();
}
public void clealAsytaskList() {
this.presenter.clealAsytaskList();
}
}
| true
|
a454c801b2d636cd0e46dddb5d1e5c9b3c1a95db
|
Java
|
zhongxingyu/Seer
|
/Diff-Raw-Data/16/16_825aa447df31b37d15c0c330db40a61f2085ecf4/DsParserForAllowMultipleUsersTestCase/16_825aa447df31b37d15c0c330db40a61f2085ecf4_DsParserForAllowMultipleUsersTestCase_t.java
|
UTF-8
| 3,665
| 1.695313
| 2
|
[] |
no_license
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.jca.common.metadata.ds;
import org.jboss.jca.common.api.metadata.ds.DataSources;
import org.jboss.jca.common.api.metadata.ds.v11.DataSource;
import org.jboss.jca.common.api.metadata.ds.v11.DsPool;
import org.jboss.jca.common.api.metadata.ds.v11.DsXaPool;
import org.jboss.jca.common.api.metadata.ds.v11.XaDataSource;
import org.jboss.jca.common.api.validator.ValidateException;
import org.jboss.jca.common.metadata.ParserException;
import org.jboss.jca.common.metadata.ds.v11.DsParser;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
/**
*
* Test case for parsing the allow-multiple-users functionality parameter
*
* @author <a href="jesper.pedersen@jboss.org">Jesper Pedersen</a>
*
*/
public class DsParserForAllowMultipleUsersTestCase
{
private static DsParser parser;
/**
*
* beforeClass method
*
* @throws Exception in casae of file not found
*/
@BeforeClass
public static void beforeClass() throws Exception
{
parser = new DsParser();
}
/**
*
* allow-multiple-users enabled for a datasource
*
* @throws Exception in case of parser error
*/
@Test
public void shouldHaveAllowMultipleUsersEnabled() throws Exception
{
//given
File xmlFile = new File(Thread.currentThread().getContextClassLoader()
.getResource("ds/unit/allow-multiple-users-ds.xml")
.toURI());
//when
DataSources dses = doParse(xmlFile);
//then
DataSource ds = (DataSource)dses.getDataSource().get(0);
DsPool dsPool = ds.getPool();
boolean actualAllowMultipleUsers = dsPool.isAllowMultipleUsers();
assertThat(actualAllowMultipleUsers, is(true));
//then
XaDataSource xads = (XaDataSource)dses.getXaDataSource().get(0);
DsXaPool dsXaPool = xads.getXaPool();
boolean actualXaAllowMultipleUsers = dsXaPool.isAllowMultipleUsers();
assertThat(actualXaAllowMultipleUsers, is(true));
}
private DataSources doParse(File xmlFile)
throws FileNotFoundException, ParserException, IOException, ValidateException, Exception
{
FileInputStream is = null;
try
{
is = new FileInputStream(xmlFile);
//when
return parser.parse(is);
}
finally
{
if (is != null)
is.close();
}
}
}
| true
|
c35be95314180803282362a6afc08c21d716d985
|
Java
|
xueliangli/today-algs
|
/algs-noob/src/algs/search/TreeSearch.java
|
UTF-8
| 4,079
| 4.03125
| 4
|
[] |
no_license
|
package algs.search;
import java.util.Stack;
/**
* @program: algs-noob
* @description: ไบๅๆๅบๆ ๏ผBSTๆ ๏ผ
* @author: ๆๅญฆไบฎ
* @create: 2019-01-07 10:00
**/
public class TreeSearch {
public TreeNode root;
private int size;
/**
* @Description:ๅ
้จ็ฑป๏ผๆ ็่็น
* @Author: ๆๅญฆไบฎ
* @Date: 2019/1/7
*/
private class TreeNode<T> {
private Integer data;
private TreeNode parent;
private TreeNode left;
private TreeNode right;
public TreeNode(Integer data) {
this.data = data;
}
@Override
public String toString() {
return "TreeNode{" +
"data=" + data +
'}';
}
}
/**
* @Description:ๅๆ ไธญๆๅ
ฅๆฐๆฎ
* @Param: [data]
* @return: java.lang.Boolean
* @Author: ๆๅญฆไบฎ
* @Date: 2019/1/7
*/
public void addTreeNode(Integer data) {
if (null == root) {
root = new TreeNode(data);
System.out.println("ๆๅ
ฅๆๅ");
return;
}
TreeNode<Integer> treeNode = new TreeNode<>(data);
TreeNode<Integer> currentNode = root;
TreeNode<Integer> parentNode;
while (true) {
parentNode = currentNode;
if (currentNode.data < data) {
currentNode = currentNode.right;
if (null == currentNode) {
parentNode.right = treeNode;
treeNode.parent = parentNode;
System.out.println("ๆๅ
ฅๆๅ");
size++;
return;
}
} else if (currentNode.data > data) {
currentNode = currentNode.left;
if (null == currentNode) {
parentNode.left = treeNode;
treeNode.parent = parentNode;
System.out.println("ๆๅ
ฅๆๅ");
size++;
return;
}
} else {
System.out.println("ๆๅ
ฅ่็น็ธๅ");
return;
}
}
}
/**
* @Description: ๆฅๆพๆ ไธญๆฏๅฆๅซๆ็ธๅบ่็น
* @Param: [data]
* @return: algs.search.TreeSearch.TreeNode
* @Author: ๆๅญฆไบฎ
* @Date: 2019/1/7
*/
public TreeNode findTreeNode(Integer data) {
if (null == root) {
return null;
}
TreeNode current = root;
while (current != null) {
if (current.data > data) {
current = current.left;
} else if (data > current.data) {
current = current.right;
} else {
return current;
}
}
return null;
}
/**
* @Description: ไธญๅบ้ๅ็้ๅฝๅฎ็ฐ, ่งๅ๏ผๅทฆ---ๆ น---ๅณ
* @Param: [treeNode]
* @return: void
* @Author: ๆๅญฆไบฎ
* @Date: 2019/1/7
*/
public static void medOrderRecursion(TreeNode treeNode) {
if (null != treeNode) {
if (null != treeNode.left) {
medOrderRecursion(treeNode.left);
}
System.out.print(treeNode.data + " ");
if (null != treeNode.right) {
medOrderRecursion(treeNode.right);
}
}
}
/**
* @Description: ๅพช็ฏๅฎ็ฐไธญๅบ้ๅ
* @Param: [treeNode]
* @return: void
* @Author: ๆๅญฆไบฎ
* @Date: 2019/1/7
*/
public static void medOrderLoop(TreeNode treeNode) {
Stack<TreeNode> stack = new Stack<>();
TreeNode current = treeNode;
while (current != null || !stack.isEmpty()) {
while (current != null) {
stack.push(current);
current = current.left;
}
if (!stack.isEmpty()) {
current = stack.pop();
System.out.print(current.data + " ");
current = current.right;
}
}
}
}
| true
|
f41bf65eb5a8e3a8cc3e41c6051cc683163fa6eb
|
Java
|
richyyjd/nova
|
/app/src/main/java/com/lopez/richard/nova_v6_en2/MainActivity.java
|
UTF-8
| 35,588
| 1.507813
| 2
|
[] |
no_license
|
package com.lopez.richard.nova_v6_en2;
/**
* Created by Richard on 31-March-2018
*/
import android.content.Intent;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Environment;
import android.os.StrictMode;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.Html;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import com.ibm.watson.developer_cloud.conversation.v1.model.InputData;
import com.ibm.watson.developer_cloud.conversation.v1.model.MessageOptions;
import com.ibm.watson.developer_cloud.language_translator.v2.LanguageTranslator;
import com.ibm.watson.developer_cloud.language_translator.v2.model.Language;
import com.ibm.watson.developer_cloud.language_translator.v2.model.TranslationResult;
import com.ibm.watson.developer_cloud.speech_to_text.v1.SpeechToText;
import com.ibm.watson.developer_cloud.speech_to_text.v1.model.RecognizeOptions;
import com.ibm.watson.developer_cloud.speech_to_text.v1.model.SpeechResults;
import com.ibm.watson.developer_cloud.speech_to_text.v1.model.Transcript;
//import com.ibm.watson.developer_cloud.conversation.v1.ConversationService;
import com.ibm.watson.developer_cloud.conversation.v1.Conversation;
import com.ibm.watson.developer_cloud.conversation.v1.model.MessageRequest;
import com.ibm.watson.developer_cloud.conversation.v1.model.MessageResponse;
import com.ibm.watson.developer_cloud.android.library.audio.StreamPlayer;
import com.ibm.watson.developer_cloud.text_to_speech.v1.model.Voice;
import com.ibm.watson.developer_cloud.text_to_speech.v1.TextToSpeech;
import com.ibm.watson.developer_cloud.tone_analyzer.v3.ToneAnalyzer;
import com.ibm.watson.developer_cloud.tone_analyzer.v3.model.ToneAnalysis;
import com.ibm.watson.developer_cloud.tone_analyzer.v3.model.ToneCategory;
import com.ibm.watson.developer_cloud.tone_analyzer.v3.model.ToneScore;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class MainActivity extends AppCompatActivity {
Intent newIntent;
TextView tv_consola;
File filePath;
private static final String APP_TAG_VS_STT = "NOVA-STT";
private static final String APP_TAG_NOVABOT = "NOVA-BOT: ";
private static final String APP_TAG_NOVA_RECORD = "NOVA-RECORD: ";
private static final String APP_TAG_NOVA_TONEANALYSER = "NOVA-TONE_ANALYZER: ";
private static final String APP_TAG_NOVA_TRANSLATOR = "NOVA-TRANSLATOR: ";
//GRABACION
public Button btn_start, btn_stop;
private static final String AUDIO_RECORDER_FOLDER = "NOVARecords";
private static final String AUDIO_RECORDER_FILE_NAME = "grabacionNova1";
private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
private static final String ARCHIVO_MENSAJE_TXT = "mensaje.txt";
private static final String ARCHIVO_RESPUESTA_TXT = "respuesta.txt";
private static final int RECORDER_BPP = 16;
private static final String AUDIO_RECORDER_TEMP_FILE = "record_temp.raw";
private static final int RECORDER_SAMPLERATE = 44100;
private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_STEREO;
private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
private AudioRecord recorder = null;
private int bufferSize = 0;
private Thread recordingThread = null;
private boolean isRecording = false;
// FIN BLOQUE GRABACION
SpeechToText stt_service;
SpeechResults speechResults;
//-- credenciales 2018
private static final String CONVERSATION_SERVICE_WORKSPACE = "WORKSPACE-ID";
private static final String CONVERSATION_SERVICE_USERNAME = "USERNAME";
private static final String CONVERSATION_SERVICE_PASSWORD = "PASSWORD";
private static final String TTS_SERVICE_USERNAME = "USERNAME";
private static final String TTS_SERVICE_PASSWORD = "PASSWORD";
private static final String STT_SERVICE_USERNAME = "USERNAME";
private static final String STT_SERVICE_PASSWORD = "PASSWORD";
//--- fin credenciales
String pathDirectorio;
String pathArchivoTexto;
String textoLeidoDelTxt;
String texto;
// ----- BOT
private Map<String, Object> context = new HashMap<>();
// --- TTS
StreamPlayer streamPlayer;
// WEATHER
final static String APP_NOVA_WEATHER = "NOVA_WEATHER";
// Tone Analyzer
private ToneAnalyzer ta_service;
//final String username_TA = "xxxxxxxxxxx";
//final String password_TA = "yyyyyyyyyyy";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// INICIO BLOQUE GRABACION
enableButtons(false);
bufferSize = AudioRecord.getMinBufferSize(8000, AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT);
btn_start = (Button) findViewById(R.id.btnStart);
btn_stop = (Button) findViewById(R.id.btnStop);
btn_start.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Log.d(APP_TAG_NOVA_RECORD, "START Grabaciรณn");
enableButtons(true);
startRecording();
}
});
btn_stop.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Log.d(APP_TAG_NOVA_RECORD, "STOP Grabaciรณn");
enableButtons(false);
stopRecording();
// LLAMOS AL METODO QUE ACCEDE A LA GRABACIOM Y QUE LUEGO ENVIA A WATSON
conversorSTT();
}
});
// FIN BLOQUE GRABACION
tv_consola = findViewById(R.id.consolatxt);
}
public void conversorSTT() {
filePath = new File(Environment.getExternalStorageDirectory()
+ File.separator
+ AUDIO_RECORDER_FOLDER
+ File.separator
+ AUDIO_RECORDER_FILE_NAME
+ AUDIO_RECORDER_FILE_EXT_WAV);
Log.d(APP_TAG_VS_STT, "getPath: " + filePath.getPath());
Log.d(APP_TAG_VS_STT, "getAboslutePath: " + filePath.getAbsolutePath());
setPathDirectorio(Environment.getExternalStorageDirectory() + File.separator + AUDIO_RECORDER_FOLDER);
Log.d(APP_TAG_VS_STT, "DIRECTORIO: " + getPathDirectorio());
newIntent = new Intent();
newIntent.setDataAndType(Uri.parse("file://" + filePath), "audio/*");
//String archivo = newIntent.getData().toString();
try {
speechToText2(newIntent.getData());
} catch (IOException e) {
e.printStackTrace();
}
}
public synchronized void actualizarConsola() {
tv_consola.setText(leemosArchitoDeTexto(ARCHIVO_MENSAJE_TXT));
}
public synchronized void speechToText2(final Uri uri) throws IOException {
final File audio = downloadWavFile(uri);
Log.d(APP_TAG_VS_STT, "ENTRAMOS A speechToText2()");
Log.d(APP_TAG_VS_STT, "Verificamos archivo de audio: " + filePath);
stt_service = new SpeechToText();
stt_service.setUsernameAndPassword(STT_SERVICE_USERNAME, STT_SERVICE_PASSWORD);
final RecognizeOptions options2 = new RecognizeOptions.Builder()
.continuous(true)
.interimResults(true)
.contentType("audio/wav")
.model("es-ES_BroadbandModel")
.build();
new Thread(new Runnable() {
@Override
public void run() {
speechResults = stt_service.recognize(audio, options2).execute();
StringBuilder sb = new StringBuilder();
for (Transcript transcript : speechResults.getResults()) {
String word = transcript.getAlternatives().get(0).getTranscript();
sb.append(word);
}
Log.d(APP_TAG_VS_STT, " ANTES DE QUE MUERA creamos archivo de texto");
setTexto(sb.toString());
Log.d(APP_TAG_VS_STT, " set set set texto @@@@@@@@@@@@@@@@@@@@@@@ " + getTexto() + " @@@@@@@@@@@@@@@@");
crearArchivoTxt222(ARCHIVO_MENSAJE_TXT, sb.toString());
runOnUiThread(new Runnable() {
@Override
public void run() {
actualizarConsola();
}
});
Log.d(APP_TAG_VS_STT, " $$$$$$$$$$$$$ " + sb.toString() + " $$$$$$$$$$$$$");
Log.d(APP_TAG_VS_STT, "<<<<<<<<<<<<<<<<< A PUNTO DE ENVIAR PREGUNTA A WATSON >>>>>>>>>>>>>>>");
Log.d(APP_TAG_VS_STT, "<<<<<<<<<<<<<<<<< A PUNTO DE ENVIAR PREGUNTA A WATSON >>>>>>>>>>>>>>>");
sendMessageToWatsonBot(sb.toString());
Log.d(APP_TAG_VS_STT, "<<<<<<<<<<<<<<<<< PREGUNTA A WATSON ENVIADA >>>>>>>>>>>>>>>");
Log.d(APP_TAG_VS_STT, "<<<<<<<<<<<<<<<<< PREGUNTA A WATSON ENVIADA >>>>>>>>>>>>>>>");
Log.d(APP_TAG_NOVABOT, "---------------------------------------------");
Log.d(APP_TAG_NOVABOT, "--------- RESPUESTA DE WATSON ---------------");
//Log.d(APP_TAG_NOVABOT, "--------- " + getRespuestaWatson() + " ---------------");
Log.d(APP_TAG_NOVABOT, "---------------------------------------------");
}
}).start();
//Fuera del HILO el texto almacenado MUERE y no es posible recuperarlo
Log.d(APP_TAG_VS_STT, getTexto() + "-----------------getTexto()------------------------------"); // muestra null
}
private File downloadWavFile(Uri uri) throws IOException {
File f = new File(getExternalFilesDir(Environment.DIRECTORY_MUSIC), "sample.wav");
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
}
InputStream is = null;
FileOutputStream fos = null;
try {
is = getContentResolver().openInputStream(uri);
fos = new FileOutputStream(f);
byte[] buf = new byte[256];
int len;
while ((len = is.read(buf, 0, buf.length)) != -1) {
fos.write(buf, 0, len);
}
} finally {
if (is != null)
is.close();
if (fos != null)
fos.close();
}
return f;
}
public synchronized void crearArchivoTxt222(String nombreArchivo, String contenido) {
String archivotxt = nombreArchivo; //"mensaje.txt"; //ARCHIVO_MENSAJE_TXT
String textoDelArchivo = contenido;
Log.d("CREADOR: ", "-- ANTES DE CREAR ARCHIVOOOO");
//Si existe archivo txt lo borramos
File f = new File(getPathDirectorio() + "/" + archivotxt);
if (f.exists()) {
f.delete();
}
File txt = new File(getPathDirectorio(), archivotxt);
Log.d("CREADOR: ", "-- OK ARCHIVO creadooo");
Log.d("CREADOR: ", txt.getPath());
setPathArchivoTexto(txt.getPath());
Log.d(APP_TAG_VS_STT, "ARCHIVO TXT: " + getPathArchivoTexto());
//int file_size = Integer.parseInt(String.valueOf(txt.getPath().length()/1024));
int file_size = Integer.parseInt(String.valueOf(txt.getPath().length()));
Log.d("CREADOR: ", "TAMAรฑO - RECIEN CREADO SIN CONTENIDO: " + Integer.toString(file_size) + " Kb");
file_size = 0;
FileOutputStream escritor = null;
try {
escritor = new FileOutputStream(new File(txt.getPath()), true); // true es igual q Context.MODE_APPEND
escritor.write(textoDelArchivo.getBytes());
file_size = Integer.parseInt(String.valueOf(txt.getPath().length()));
Log.d("YOOOOOO: ", "TAMAรฑO - DESPUES DE SER CREADO + CON CONTENIDO: " + Integer.toString(file_size) + " Kb");
} catch (Exception ex) {
Log.e("YOOOO", "Error al escribir fichero a memoria interna");
ex.printStackTrace();
}
}
public void setPathDirectorio(String pathDirectorio) {
this.pathDirectorio = pathDirectorio;
}
public String getPathDirectorio() {
return pathDirectorio;
}
public void setPathArchivoTexto(String pathArchivoTexto) {
this.pathArchivoTexto = pathArchivoTexto;
}
public String getPathArchivoTexto() {
return pathArchivoTexto;
}
public String getTexto() {
return texto;
}
public void setTexto(String texto) {
this.texto = texto;
}
public synchronized String leemosArchitoDeTexto(String queArchivoLeemos) {
File f = new File(getPathDirectorio() + "/" + queArchivoLeemos);//ARCHIVO_MENSAJE_TXT);
FileInputStream fileIn = null;
try {
fileIn = new FileInputStream(f.getPath());
} catch (FileNotFoundException e) {
e.printStackTrace();
}
InputStreamReader inputRead = new InputStreamReader(fileIn);
char[] inputBuffer = new char[100];
String s = "";
int charRead;
try {
while ((charRead = inputRead.read(inputBuffer)) > 0) {
// char to string conversion
String readstring = String.copyValueOf(inputBuffer, 0, charRead);
s += readstring;
}
textoLeidoDelTxt = s;
inputRead.close();
} catch (IOException e) {
e.printStackTrace();
}
Log.d("LEYENDO: ", "ssss--- " + s + " ---");
Log.d("LEYENDO: ", "textoLeidoDelTxt:--- " + textoLeidoDelTxt + " ---");
return textoLeidoDelTxt;
}
private synchronized void sendMessageToWatsonBot(String msg_to_watson) {
Log.d(APP_TAG_NOVABOT, " -- INICIO del metodo sendMessageToWatsonBot -- var recibida: " + msg_to_watson);
final String pregunta = msg_to_watson;
final String userText_analizar = msg_to_watson;
//final String userText_a_traducir = msg_to_watson;
Log.d(APP_TAG_NOVABOT, "REVISANDO - PARAMETRO RECIBIDO: " + pregunta);
Log.d(APP_TAG_NOVABOT, "REVISANDO - MSG ENVIADO: " + pregunta);
Thread thread = new Thread(new Runnable() {
public void run() {
try {
Log.d(APP_TAG_NOVABOT, " INICIO CREDENCIALES PARA EL BOT");
//antiguo
/*
final ConversationService service = new ConversationService(ConversationService.VERSION_DATE_2016_09_20);
service.setUsernameAndPassword("bdfc8ba7-5d73-49cb-a410-1ac0c233f5e7", "jVEDCP3Ey4U2");
*/
Log.d(APP_TAG_NOVABOT, " FIN CREDENCIALES PARA EL BOT");
/////------------TONE ANALYZER
/*
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
ta_service = new ToneAnalyzer(ToneAnalyzer.VERSION_DATE_2016_05_19);
ta_service.setUsernameAndPassword(username_TA, password_TA);
// Call the service and get the tone
ToneAnalysis tone = ta_service.getTone(userText_analizar, null).execute();//
Log.d("SIMPLETONEA", tone.toString());
for (ToneCategory tc : tone.getDocumentTone().getTones()) {
Log.d("SIMPLEToneA", "=============== NEW CATEGORY: *" + tc.getName() + "*==================");
for (ToneScore ts : tc.getTones()) {
switch (ts.getName()) {
case "Anger":
//
if (ts.getScore() >= 0.75) {
Log.d("Control IF", ">=0.75: " + ts.getName() + ", Score: " + String.valueOf(ts.getScore()));
}
break;
case "Disgust":
//
if (ts.getScore() >= 0.75) {
Log.d("Control IF", ">=0.75: " + ts.getName() + ", Score: " + String.valueOf(ts.getScore()));
}
break;
case "Fear":
if (ts.getScore() >= 0.75) {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Control IF >=0.75: " + ts.getName() + ", Score: " + String.valueOf(ts.getScore()));
Log.d(APP_TAG_NOVA_TONEANALYSER, userText_analizar);
String claveFear75 = "Miedo75";
MessageRequest newMessage = new MessageRequest.Builder().inputText(claveFear75).context(context).build();
MessageResponse response = service.message("75bffb0a-149e-4ce0-8206-6d68921e3b5a", newMessage).execute(); //workspaceID, message
if (response.getOutput() != null && response.getOutput().containsKey("text")) {
final String mensajeDeAlivio = response.getOutput().get("text").toString().replace("[", "").replace("]", "");
Log.d(APP_TAG_NOVA_TONEANALYSER, mensajeDeAlivio);
executeWatsonTTS("Fear " + String.valueOf((int) (ts.getScore() * 100)) + "%. " + mensajeDeAlivio.toString());
} else {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Texto vacio: -" + userText_analizar + "-");
}
}
break;
case "Joy":
//
if (ts.getScore() >= 0.75) {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Control IF >=0.75: " + ts.getName() + ", Score: " + String.valueOf(ts.getScore()));
Log.d(APP_TAG_NOVA_TONEANALYSER, userText_analizar);
String claveJoy75 = "Alegria75";
MessageRequest newMessage = new MessageRequest.Builder().inputText(claveJoy75).context(context).build();
MessageResponse response = service.message("75bffb0a-149e-4ce0-8206-6d68921e3b5a", newMessage).execute();
if (response.getOutput() != null && response.getOutput().containsKey("text")) {
final String mensajeDeAlivio = response.getOutput().get("text").toString().replace("[", "").replace("]", "");
Log.d(APP_TAG_NOVA_TONEANALYSER, mensajeDeAlivio);
executeWatsonTTS("Joy " + String.valueOf((int) (ts.getScore() * 100)) + "%. " + mensajeDeAlivio.toString());
} else {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Texto vacio: -" + userText_analizar + "-");
}
}
break;
case "Sadness":
//
if (ts.getScore() >= 0.75) {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Control IF >=0.75: " + ts.getName() + ", Score: " + String.valueOf(ts.getScore()));
Log.d(APP_TAG_NOVA_TONEANALYSER, userText_analizar);
String claveSadness75 = "Tristeza75";
MessageRequest newMessage = new MessageRequest.Builder().inputText(claveSadness75).context(context).build();
MessageResponse response = service.message("75bffb0a-149e-4ce0-8206-6d68921e3b5a", newMessage).execute();
if (response.getOutput() != null && response.getOutput().containsKey("text")) {
final String mensajeDeAlivio = response.getOutput().get("text").toString().replace("[", "").replace("]", "");
Log.d(APP_TAG_NOVA_TONEANALYSER, mensajeDeAlivio);
executeWatsonTTS("Sadness " + String.valueOf((int) (ts.getScore() * 100)) + "%. " + mensajeDeAlivio.toString());
} else {
Log.d(APP_TAG_NOVA_TONEANALYSER, "Texto vacio: -" + userText_analizar + "-");
}
}
break;
default:
//
break;
}
}
}
}
});
*/
/////-----FIN -------TONE ANALYZER
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
////////------------------ Conversation 2018
com.ibm.watson.developer_cloud.conversation.v1.model.Context context = null;
Conversation service = new Conversation(Conversation.VERSION_DATE_2017_05_26);
service.setUsernameAndPassword(CONVERSATION_SERVICE_USERNAME, CONVERSATION_SERVICE_PASSWORD);
InputData input = new InputData.Builder(pregunta).build();
MessageOptions options = new MessageOptions.Builder(CONVERSATION_SERVICE_WORKSPACE).input(input).context(context).build();
MessageResponse response = service.message(options).execute();
Log.d(APP_TAG_NOVABOT, "=============================: "+response.getOutput().get("text").toString().replace("[","").replace("]",""));
////////------------------ FIN - Conversation 2018
/*if (response.getContext() != null) {
context.clear();
context = response.getContext();
}*/
if (response != null) {
if (response.getOutput() != null && response.getOutput().containsKey("text")) {
final String outputmessage = response.getOutput().get("text").toString().replace("[", "").replace("]", "");
//Menssaje RESPUESTA recibido desde WATSON
Log.d(APP_TAG_NOVABOT, "MSG RECIBIDO DE WATSON: -" + outputmessage + "-");
Log.d(APP_TAG_NOVABOT, "VERIFICANDO - MSG RECIBIDO DE WATSON: " + outputmessage);//getRespuestaDeWatson());
// tv_consola.setText(outputmessage.toString()); //ESTO DETENIA QUE SE EJECUTE EL RESTO
/*
//control clima
Log.d(APP_TAG_NOVABOT, "Antes de executeWatson ");
final String respuestaClaveWeather = "Here is the weather forecast";
if (outputmessage.equalsIgnoreCase(respuestaClaveWeather)) {
Log.d(APP_TAG_NOVABOT, "ENTRA AL IF --- respuestaClaveWeather:-" + respuestaClaveWeather + "-");
Function.placeIdTask asyncTask = new Function.placeIdTask(new Function.AsyncResponse() {
public void processFinish(String weather_city, String weather_description, String weather_temperature, String weather_humidity, String weather_pressure, String weather_updatedOn, String weather_iconText, String sun_rise) {
Log.d(APP_TAG_NOVABOT, "ENTRO A FUNCTION");
Log.d(APP_NOVA_WEATHER, "weather_city: " + weather_city);
Log.d(APP_NOVA_WEATHER, "weather_updatedOn: " + weather_updatedOn);
Log.d(APP_NOVA_WEATHER, "weather_description --ANTES: " + weather_description);
Log.d(APP_NOVA_WEATHER, "weather_temperature: " + weather_temperature);
Log.d(APP_NOVA_WEATHER, "weather_humidity: " + weather_humidity);
Log.d(APP_NOVA_WEATHER, "weather_pressure: " + weather_pressure);
Log.d("APP_NOVA_WEATHER", "=============== REPORTE DEL CLIMA ==================");
final String watsonWeatherTexto = respuestaClaveWeather + " " +
weather_city + ". " +
weather_temperature + ". " +
weather_description + ". " +
"Humidity: " + weather_humidity + ". " +
"Pressure: " + weather_pressure;
Log.d("APP_NOVA_WEATHER", "=============== " + watsonWeatherTexto + " ==================");
executeWatsonTTS(watsonWeatherTexto);
//executeWatsonTTS(weather_city);
}
});
asyncTask.execute("-17.389500", "-66.156799"); //Cochabamba
//asyncTask.execute("47.066669", "15.450000"); //Graz
////////----------------
} else {
*/
//executeWatsonTTS(outputmessage);
hablaWatsonTTS(outputmessage);
Log.d(APP_TAG_NOVABOT, "Despues de executeWatson ");
//}
}
}
}
//}).start();
});
/*
//tone analizer
thread1.start();
thread1.join();
*/
thread2.start();
thread2.join();
} catch (Exception e) {
e.printStackTrace();
}
}
});
thread.start();
}
/**
* TTS
*/
private void hablaWatsonTTS(String textoParaHablar){
TextToSpeech service = new TextToSpeech();
service.setUsernameAndPassword(TTS_SERVICE_USERNAME, TTS_SERVICE_PASSWORD);
try {
Log.d(APP_TAG_NOVABOT, "======== 1");
streamPlayer = new StreamPlayer();
Log.d(APP_TAG_NOVABOT, "======== 2");
streamPlayer.playStream(service.synthesize(textoParaHablar, Voice.ES_SOFIA).execute());
Log.d(APP_TAG_NOVABOT, "======== 3");
}
catch (Exception e) {
e.printStackTrace();
}
}
/**
* MODULO: GRABACION
*/
private void enableButton(int id, boolean isEnable) {
((Button) findViewById(id)).setEnabled(isEnable);
}
/**
* MODULO: GRABACION
*/
private void enableButtons(boolean isRecording) {
enableButton(R.id.btnStart, !isRecording);
enableButton(R.id.btnStop, isRecording);
}
/**
* MODULO: GRABACION
*/
private String getFilename() {
String filepath = Environment.getExternalStorageDirectory().getPath();
File file = new File(filepath, AUDIO_RECORDER_FOLDER);
if (!file.exists()) {
file.mkdirs();
}
Log.d("RUTA DE GRABACION: ", "--------- " + file.getAbsolutePath());
setPathDirectorio(file.getAbsolutePath());
String archivoGrabado = file.getAbsolutePath() + "/" + AUDIO_RECORDER_FILE_NAME + AUDIO_RECORDER_FILE_EXT_WAV; //MODIFICADO 2
Log.d("RUTA DE GRABACION: ", archivoGrabado);
return archivoGrabado;
}
/**
* MODULO: GRABACION
*/
private String getTempFilename() {
String filepath = Environment.getExternalStorageDirectory().getPath();
File file = new File(filepath, AUDIO_RECORDER_FOLDER);
if (!file.exists()) {
file.mkdirs();
}
File tempFile = new File(filepath, AUDIO_RECORDER_TEMP_FILE);
if (tempFile.exists())
tempFile.delete();
return (file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE);
}
/**
* MODULO: GRABACION
*/
private void startRecording() {
recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
RECORDER_SAMPLERATE, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING, bufferSize);
int i = recorder.getState();
if (i == 1)
recorder.startRecording();
isRecording = true;
recordingThread = new Thread(new Runnable() {
@Override
public void run() {
writeAudioDataToFile();
}
}, "AudioRecorder Thread");
recordingThread.start();
}
/**
* MODULO: GRABACION
*/
private void writeAudioDataToFile() {
byte data[] = new byte[bufferSize];
String filename = getTempFilename();
FileOutputStream os = null;
try {
os = new FileOutputStream(filename);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
int read = 0;
if (null != os) {
while (isRecording) {
read = recorder.read(data, 0, bufferSize);
if (AudioRecord.ERROR_INVALID_OPERATION != read) {
try {
os.write(data);
} catch (IOException e) {
e.printStackTrace();
}
}
}
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* MODULO: GRABACION
*/
private void stopRecording() {
if (null != recorder) {
isRecording = false;
int i = recorder.getState();
if (i == 1)
recorder.stop();
recorder.release();
recorder = null;
recordingThread = null;
}
copyWaveFile(getTempFilename(), getFilename());
deleteTempFile();
}
/**
* MODULO: GRABACION
*/
private void deleteTempFile() {
File file = new File(getTempFilename());
file.delete();
}
/**
* MODULO: GRABACION
*/
private void copyWaveFile(String inFilename, String outFilename) {
FileInputStream in = null;
FileOutputStream out;
long totalAudioLen = 0;
long totalDataLen = totalAudioLen + 36;
long longSampleRate = RECORDER_SAMPLERATE;
int channels = 2;
long byteRate = RECORDER_BPP * RECORDER_SAMPLERATE * channels / 8;
byte[] data = new byte[bufferSize];
try {
in = new FileInputStream(inFilename);
out = new FileOutputStream(outFilename);
totalAudioLen = in.getChannel().size();
totalDataLen = totalAudioLen + 36;
Log.d(APP_TAG_NOVA_RECORD, "File size: " + totalDataLen);
WriteWaveFileHeader(out, totalAudioLen, totalDataLen,
longSampleRate, channels, byteRate);
while (in.read(data) != -1) {
out.write(data);
}
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* MODULO: GRABACION
*/
private void WriteWaveFileHeader(
FileOutputStream out, long totalAudioLen,
long totalDataLen, long longSampleRate, int channels, long byteRate) throws IOException {
byte[] header = new byte[44];
header[0] = 'R'; // RIFF/WAVE header
header[1] = 'I';
header[2] = 'F';
header[3] = 'F';
header[4] = (byte) (totalDataLen & 0xff);
header[5] = (byte) ((totalDataLen >> 8) & 0xff);
header[6] = (byte) ((totalDataLen >> 16) & 0xff);
header[7] = (byte) ((totalDataLen >> 24) & 0xff);
header[8] = 'W';
header[9] = 'A';
header[10] = 'V';
header[11] = 'E';
header[12] = 'f'; // 'fmt ' chunk
header[13] = 'm';
header[14] = 't';
header[15] = ' ';
header[16] = 16; // 4 bytes: size of 'fmt ' chunk
header[17] = 0;
header[18] = 0;
header[19] = 0;
header[20] = 1; // format = 1
header[21] = 0;
header[22] = (byte) channels;
header[23] = 0;
header[24] = (byte) (longSampleRate & 0xff);
header[25] = (byte) ((longSampleRate >> 8) & 0xff);
header[26] = (byte) ((longSampleRate >> 16) & 0xff);
header[27] = (byte) ((longSampleRate >> 24) & 0xff);
header[28] = (byte) (byteRate & 0xff);
header[29] = (byte) ((byteRate >> 8) & 0xff);
header[30] = (byte) ((byteRate >> 16) & 0xff);
header[31] = (byte) ((byteRate >> 24) & 0xff);
header[32] = (byte) (2 * 16 / 8); // block align
header[33] = 0;
header[34] = RECORDER_BPP; // bits per sample
header[35] = 0;
header[36] = 'd';
header[37] = 'a';
header[38] = 't';
header[39] = 'a';
header[40] = (byte) (totalAudioLen & 0xff);
header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
header[43] = (byte) ((totalAudioLen >> 24) & 0xff);
out.write(header, 0, 44);
}
}
| true
|
5b370453d7a0879c5f2aa2b0cc5deb28d5c444c0
|
Java
|
GeorgeConIV/MIPS
|
/src/Main.java
|
UTF-8
| 663
| 2.703125
| 3
|
[] |
no_license
|
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class Main {
public static void main(String[] args)
{
FileManipulator fileMan = new FileManipulator();
fileMan.initFileScanner("Test.txt");
AsmScanner scan = new AsmScanner(fileMan.getListOfTokensWhitespaceDelimited());
List<Instruction> insts = scan.getInstructions();
List<String> printed = new ArrayList<>();
int i = 0;
while(insts.size() > i)
{
printed.add(insts.get(i).getBitstream());
i++;
}
fileMan.writeListOfTokens(printed, Optional.empty());
}
}
| true
|
6a32c558a4a6ea5506406fd9994206f428dcbc48
|
Java
|
Motiveko/design-patterns
|
/src/com/motiveko/designpatterns/creational/prototype/game/HeroFactory.java
|
UTF-8
| 172
| 2.359375
| 2
|
[] |
no_license
|
package com.motiveko.designpatterns.creational.prototype.game;
public interface HeroFactory {
Mage createMage();
Beast createBeast();
Warlord createWarlord();
}
| true
|
7c6c208403ff760cc23f2d6e98080b625af58005
|
Java
|
hsutimes/bridge
|
/src/org/bridge/basic/Test5.java
|
UTF-8
| 1,215
| 3.734375
| 4
|
[] |
no_license
|
package org.bridge.basic;
import java.util.*;
/**
* ้ฎ้ขๆ่ฟฐ
* ็ปๅบไธไธชๅ
ๅซnไธชๆดๆฐ็ๆฐๅ๏ผ้ฎๆดๆฐaๅจๆฐๅไธญ็็ฌฌไธๆฌกๅบ็ฐๆฏ็ฌฌๅ ไธชใ
* <p>
* ่พๅ
ฅๆ ผๅผ
* ็ฌฌไธ่กๅ
ๅซไธไธชๆดๆฐnใ
* <p>
* ็ฌฌไบ่กๅ
ๅซnไธช้่ดๆดๆฐ๏ผไธบ็ปๅฎ็ๆฐๅ๏ผๆฐๅไธญ็ๆฏไธชๆฐ้ฝไธๅคงไบ10000ใ
* <p>
* ็ฌฌไธ่กๅ
ๅซไธไธชๆดๆฐa๏ผไธบๅพ
ๆฅๆพ็ๆฐใ
* <p>
* ่พๅบๆ ผๅผ
* ๅฆๆaๅจๆฐๅไธญๅบ็ฐไบ๏ผ่พๅบๅฎ็ฌฌไธๆฌกๅบ็ฐ็ไฝ็ฝฎ(ไฝ็ฝฎไป1ๅผๅง็ผๅท)๏ผๅฆๅ่พๅบ-1ใ
* ๆ ทไพ่พๅ
ฅ
* 6
* 1 9 4 8 3 9
* 9
* ๆ ทไพ่พๅบ
* 2
* ๆฐๆฎ่งๆจกไธ็บฆๅฎ
* 1 <= n <= 1000ใ
*
* @author times
* Time: 2017-11-08 23:33
*/
public class Test5 {
public static void main(String[] args) {
}
public Test5() {
Scanner sc = new Scanner(System.in);
int n, x, index = -1;
n = sc.nextInt();
int[] num = new int[n];
for (int i = 0; i < n; i++) {
num[i] = sc.nextInt();
}
x = sc.nextInt();
for (int i = 0; i < n; i++) {
if (x == num[i]) {
index = i + 1;
break;
}
}
System.out.println(index);
}
}
| true
|
a694c6a73ee188ecd0627c23d05b6dc88c07ee5c
|
Java
|
MichaelSp/Sitzplaner
|
/src/src/main/java/net/sprauer/sitzplaner/view/Blackboard.java
|
UTF-8
| 704
| 2.359375
| 2
|
[] |
no_license
|
package net.sprauer.sitzplaner.view;
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JPanel;
import net.sprauer.sitzplaner.view.helper.Parameter;
public class Blackboard extends JPanel {
public static final Color DEFAULT_BLACKBOARD_COLOR = new Color(0, 60, 0);
private static final long serialVersionUID = -8750925029559567754L;
public Blackboard() {
setBackground(DEFAULT_BLACKBOARD_COLOR);
}
public void init(Dimension size) {
setSize(Parameter.maxWidth, Parameter.blackboardHeight);
setLocation(Parameter.offsetX, size.height - Parameter.blackboardHeight);
}
public void highlight(boolean b) {
setBackground(b ? Color.gray : DEFAULT_BLACKBOARD_COLOR);
}
}
| true
|
e9248e57d7039e61db2670526460441d0fdc83d4
|
Java
|
eomcs/eomcs-java-project
|
/mini-pms-v1/app-14-a/src/main/java/com/eomcs/pms/handler/ProjectHandler.java
|
UTF-8
| 6,656
| 2.875
| 3
|
[] |
no_license
|
package com.eomcs.pms.handler;
import java.sql.Date;
import java.util.ArrayList;
import java.util.List;
import com.eomcs.pms.domain.Member;
import com.eomcs.pms.domain.Project;
import com.eomcs.util.Prompt;
public class ProjectHandler {
List<Project> projectList;
MemberHandler memberHandler;
public ProjectHandler(List<Project> projectList, MemberHandler memberHandler) {
this.projectList = projectList;
this.memberHandler = memberHandler;
Project project = new Project();
project.setNo(101);
project.setTitle("ํ๋ก์ ํธ1");
project.setContent("๋ด์ฉ!!!");
project.setStartDate(Date.valueOf("2021-1-1"));
project.setEndDate(Date.valueOf("2021-2-2"));
project.setOwner(memberHandler.memberList.get(0));
project.setMembers(new ArrayList<>());
projectList.add(project);
project = new Project();
project.setNo(102);
project.setTitle("ํ๋ก์ ํธ2");
project.setContent("๋ด์ฉ!!!");
project.setStartDate(Date.valueOf("2021-3-1"));
project.setEndDate(Date.valueOf("2021-4-2"));
project.setOwner(memberHandler.memberList.get(1));
project.setMembers(new ArrayList<>());
projectList.add(project);
project = new Project();
project.setNo(103);
project.setTitle("ํ๋ก์ ํธ3");
project.setContent("๋ด์ฉ!!!");
project.setStartDate(Date.valueOf("2021-5-1"));
project.setEndDate(Date.valueOf("2021-6-2"));
project.setOwner(memberHandler.memberList.get(2));
project.setMembers(new ArrayList<>());
projectList.add(project);
}
public void add() {
System.out.println("[ํ๋ก์ ํธ ๋ฑ๋ก]");
Project project = new Project();
project.setNo(Prompt.inputInt("๋ฒํธ? "));
project.setTitle(Prompt.inputString("ํ๋ก์ ํธ๋ช
? "));
project.setContent(Prompt.inputString("๋ด์ฉ? "));
project.setStartDate(Prompt.inputDate("์์์ผ? "));
project.setEndDate(Prompt.inputDate("์ข
๋ฃ์ผ? "));
project.setOwner(AuthHandler.getLoginUser());
project.setMembers(memberHandler.promptMembers("ํ์?(์๋ฃ: ๋น ๋ฌธ์์ด) "));
projectList.add(project);
System.out.println("ํ๋ก์ ํธ๋ฅผ ์ ์ฅํ์ต๋๋ค!");
}
//๋ค๋ฅธ ํจํค์ง์ ์๋ App ํด๋์ค๊ฐ ๋ค์ ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋๋ก ๊ณต๊ฐํ๋ค.
public void list() {
System.out.println("[ํ๋ก์ ํธ ๋ชฉ๋ก]");
for (Project project : projectList) {
System.out.printf("%d, %s, %s ~ %s, %s, [%s]\n",
project.getNo(),
project.getTitle(),
project.getStartDate(),
project.getEndDate(),
project.getOwner().getName(),
getMemberNames(project.getMembers()));
}
}
private String getMemberNames(List<Member> members) {
StringBuilder names = new StringBuilder();
for (Member member : members) {
if (names.length() > 0) {
names.append(",");
}
names.append(member.getName());
}
return names.toString();
}
public void detail() {
System.out.println("[ํ๋ก์ ํธ ์์ธ๋ณด๊ธฐ]");
int no = Prompt.inputInt("๋ฒํธ? ");
Project project = findByNo(no);
if (project == null) {
System.out.println("ํด๋น ๋ฒํธ์ ํ๋ก์ ํธ๊ฐ ์์ต๋๋ค.");
return;
}
System.out.printf("ํ๋ก์ ํธ๋ช
: %s\n", project.getTitle());
System.out.printf("๋ด์ฉ: %s\n", project.getContent());
System.out.printf("์์์ผ: %s\n", project.getStartDate());
System.out.printf("์ข
๋ฃ์ผ: %s\n", project.getEndDate());
System.out.printf("๋ง๋ ์ด: %s\n", project.getOwner().getName());
System.out.printf("ํ์: %s\n", getMemberNames(project.getMembers()));
}
public void update() {
System.out.println("[ํ๋ก์ ํธ ๋ณ๊ฒฝ]");
int no = Prompt.inputInt("๋ฒํธ? ");
Project project = findByNo(no);
if (project == null) {
System.out.println("ํด๋น ๋ฒํธ์ ํ๋ก์ ํธ๊ฐ ์์ต๋๋ค.");
return;
}
if (project.getOwner().getNo() != AuthHandler.getLoginUser().getNo()) {
System.out.println("๋ณ๊ฒฝ ๊ถํ์ด ์์ต๋๋ค.");
return;
}
String title = Prompt.inputString(String.format("ํ๋ก์ ํธ๋ช
(%s)? ", project.getTitle()));
String content = Prompt.inputString(String.format("๋ด์ฉ(%s)? ", project.getContent()));
Date startDate = Prompt.inputDate(String.format("์์์ผ(%s)? ", project.getStartDate()));
Date endDate = Prompt.inputDate(String.format("์ข
๋ฃ์ผ(%s)? ", project.getEndDate()));
List<Member> members = memberHandler.promptMembers(String.format(
"ํ์(%s)?(์๋ฃ: ๋น ๋ฌธ์์ด) ", getMemberNames(project.getMembers())));
String input = Prompt.inputString("์ ๋ง ๋ณ๊ฒฝํ์๊ฒ ์ต๋๊น?(y/N) ");
if (input.equalsIgnoreCase("n") || input.length() == 0) {
System.out.println("ํ๋ก์ ํธ ๋ณ๊ฒฝ์ ์ทจ์ํ์์ต๋๋ค.");
return;
}
project.setTitle(title);
project.setContent(content);
project.setStartDate(startDate);
project.setEndDate(endDate);
project.setMembers(members);
System.out.println("ํ๋ก์ ํธ๋ฅผ ๋ณ๊ฒฝํ์์ต๋๋ค.");
}
public void delete() {
System.out.println("[ํ๋ก์ ํธ ์ญ์ ]");
int no = Prompt.inputInt("๋ฒํธ? ");
Project project = findByNo(no);
if (project == null) {
System.out.println("ํด๋น ๋ฒํธ์ ํ๋ก์ ํธ๊ฐ ์์ต๋๋ค.");
return;
}
if (project.getOwner().getNo() != AuthHandler.getLoginUser().getNo()) {
System.out.println("์ญ์ ๊ถํ์ด ์์ต๋๋ค.");
return;
}
String input = Prompt.inputString("์ ๋ง ์ญ์ ํ์๊ฒ ์ต๋๊น?(y/N) ");
if (input.equalsIgnoreCase("n") || input.length() == 0) {
System.out.println("ํ๋ก์ ํธ ์ญ์ ๋ฅผ ์ทจ์ํ์์ต๋๋ค.");
return;
}
projectList.remove(project);
System.out.println("ํ๋ก์ ํธ๋ฅผ ์ญ์ ํ์์ต๋๋ค.");
}
public Project findByNo(int no) {
for (Project project : projectList) {
if (project.getNo() == no) {
return project;
}
}
return null;
}
public Project promptProject() {
System.out.println("ํ๋ก์ ํธ:");
for (Project project : projectList) {
System.out.printf(" %d. %s\n", project.getNo(), project.getTitle());
}
while (true) {
int projectNo = Prompt.inputInt("ํ๋ก์ ํธ ๋ฒํธ ์ ํ? (์ทจ์: 0) ");
if (projectNo == 0) {
return null;
}
Project selectedProject = findByNo(projectNo);
if (selectedProject != null) {
return selectedProject;
}
System.out.println("ํ๋ก์ ํธ ๋ฒํธ๊ฐ ์ณ์ง ์์ต๋๋ค.");
}
}
}
| true
|
242814c007899b2b765b5a5ec7feff207518ece4
|
Java
|
AlvaCorp/AndroPulsa
|
/AndroPulsa/src/id/aditya/andropulsa/database/DsPembeli.java
|
UTF-8
| 7,900
| 2.265625
| 2
|
[] |
no_license
|
package id.aditya.andropulsa.database;
import java.util.ArrayList;
import java.util.List;
import id.aditya.andropulsa.kelas.AutoObject;
import id.aditya.andropulsa.kelas.ClassPembeli;
import id.aditya.andropulsa.kelas.DataObject;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;
public class DsPembeli {
private SQLiteDatabase database;
private DbManager dbManager;
private static final String tb_data_pembeli = "tb_data_pembeli";
private static final String id_pembeli = "id_pembeli";
private static final String id_pembelix = "id_pembeli as _id";
private static final String nm_pembeli = "nm_pembeli";
private static final String alamat_pembeli = "alamat_pembeli";
private static final String tb_data_nomor = "tb_data_nomor";
private static final String id_nomor = "id_nomor";
private static final String nomor_telpon = "nomor_telpon";
private String[] allColumns = {id_pembelix,nm_pembeli,alamat_pembeli};
private String[] allColumns1 = {id_nomor,id_pembeli,nomor_telpon};
//Instance from constructor
public DsPembeli(Context context) {
dbManager = new DbManager(context);
}
//Open database connection
public void open() throws SQLException {
database = dbManager.getWritableDatabase();
}
//Close database connection
public void close(){
dbManager.close();
}
public ClassPembeli insertPembeli(String Nm_pembeli, String Alamat_pembeli){
ContentValues values = new ContentValues();
values.put(nm_pembeli, Nm_pembeli);
values.put(alamat_pembeli, Alamat_pembeli);
long insertIdPembeli = database.insert(tb_data_pembeli, null, values);
Cursor cursor = database.query(tb_data_pembeli, allColumns, id_pembeli + " = " + insertIdPembeli, null, null, null, null);
cursor.moveToFirst();
ClassPembeli returnidpembeli = cursorToIdPembeli(cursor);
cursor.close();
return returnidpembeli;
}
private ClassPembeli cursorToIdPembeli(Cursor cursor) {
// TODO Auto-generated method stub
ClassPembeli pembeli = new ClassPembeli();
pembeli.setId_pembeli(cursor.getInt(0));
return pembeli;
}
public long insertNo(int Idpembeli, String No){
ContentValues values = new ContentValues();
values.put(id_pembeli, Idpembeli);
values.put(nomor_telpon, No);
long cr = database.insert(tb_data_nomor, null, values);
return cr;
}
public Cursor fetchPembeli(){
Cursor cr = database.query(true, tb_data_pembeli, allColumns, null, null, null, null, nm_pembeli+" ASC", null);
return cr;
}
public Cursor fetchPembeliId(int idpembeli){
Cursor cr = database.query(true, tb_data_pembeli, allColumns, id_pembeli + "=?", new String[] {""+idpembeli+""}, null, null, null, null);
if(cr != null){
cr.moveToFirst();
}
return cr;
}
public List<String> fetchNomPembeli(int idpembeli){
List<String> data = new ArrayList<String>();
Cursor cr = database.query(true, tb_data_nomor, allColumns1, id_pembeli + "=?", new String[] {""+idpembeli+""}, null, null, id_nomor+" ASC", null);
for(cr.moveToFirst(); !cr.isAfterLast(); cr.moveToNext()) {
data.add(cr.getString(2));
}
return data;
}
public List<AutoObject> fetchNomPembeliId(int idNo_){
List<AutoObject> nm = new ArrayList<AutoObject>();
Cursor cr = database.query(true, tb_data_nomor, allColumns1, id_pembeli + "=?", new String[] {""+idNo_+""}, null, null, id_nomor+" ASC", null);
for(cr.moveToFirst(); !cr.isAfterLast(); cr.moveToNext()) {
//nm.add(cr.getString(0));
nm.add ( new AutoObject ( cr.getString(0).toString() , cr.getString(2).toString() ) );
}
return nm;
}
public int deleteNoPembeli(int idnomor){
int delete = database.delete(tb_data_nomor, id_nomor + " = " + idnomor, null);
return delete;
}
public int deleteNoPembeliId(int idpembeli){
int delete = database.delete(tb_data_nomor, id_pembeli + " = " + idpembeli, null);
return delete;
}
public int deletePembeli(int idpembeli){
int delete = database.delete(tb_data_pembeli, id_pembeli + " = " + idpembeli, null);
return delete;
}
public Cursor updateDataPembeli(String nmPembeli, String almtPembeli, int idPembeli){
String updateQuery = "UPDATE "+ tb_data_pembeli +" SET nm_pembeli='"+ nmPembeli +"',alamat_pembeli='"+ almtPembeli +
"' WHERE "+ id_pembeli +" = "+ idPembeli +"";
Cursor cr = database.rawQuery(updateQuery, null);
if(cr != null){
cr.moveToFirst();
}
return cr;
}
public Cursor updateDataNoPembeli(String noTelp, int idNomor){
String updateQuery = "UPDATE "+ tb_data_nomor +" SET nomor_telpon='"+ noTelp +"' WHERE "+ id_nomor +" = "+ idNomor +"";
Cursor cr = database.rawQuery(updateQuery, null);
if(cr != null){
cr.moveToFirst();
}
return cr;
}
public List<DataObject> fetchDataPembeli(){
List<DataObject> data = new ArrayList<DataObject>();
Cursor cr = database.query(true, tb_data_pembeli, allColumns, null, null, null, null, nm_pembeli+" ASC", null);
for(cr.moveToFirst(); !cr.isAfterLast(); cr.moveToNext()) {
data.add ( new DataObject ( cr.getString(0).toString() , cr.getString(1).toString() ) );
}
return data;
}
public Cursor fetchSearchPembeli(String cons){
Cursor cr = database.query(true, tb_data_pembeli, allColumns, nm_pembeli + " LIKE ?", new String[] {"%"+cons+"%"}, null, null, nm_pembeli+" ASC", null);
return cr;
}
public Cursor CountPembayaran(){
String query = "SELECT DISTINCT p.id_pembeli, p.nm_pembeli, SUM(o.hrg_jual) as total, "+
"SUM(CASE WHEN t.status = '1' THEN o.hrg_jual END) as piutang, "+
"FROM tb_transaksi t, tb_data_op o, tb_data_pembeli p "+
"WHERE t.id_op = o.id_op AND t.id_pembeli = p.id_pembeli "+
"GROUP BY t.id_pembeli "+
"ORDER BY p.nm_pembeli ASC";
Cursor cr = database.rawQuery(query, null);
return cr;
}
public List<String> countPembelian(){
List<String> data1 = new ArrayList<String>();
List<String> data2 = new ArrayList<String>();
String query1 = "SELECT COUNT(*) as total FROM tb_data_pembeli";
Cursor cr1 = database.rawQuery(query1, null);
cr1.moveToFirst();
int total = cr1.getInt(0);
String query2 = "SELECT id_pembeli FROM tb_data_pembeli ORDER BY nm_pembeli ASC";
Cursor cr2 = database.rawQuery(query2, null);
for(cr2.moveToFirst(); !cr2.isAfterLast(); cr2.moveToNext()) {
data1.add(String.valueOf(cr2.getInt(0)));
}
try{
for(int i = 0; i<total; i++){
String query3 = "SELECT SUM(op.hrg_jual) FROM tb_data_op op, tb_transaksi tr WHERE op.id_op = tr.id_op AND tr.id_pembeli = "+ Integer.valueOf(data1.get(i).toString()) +"";
Cursor cr3 = database.rawQuery(query3, null);
cr3.moveToFirst();
data2.add(i, String.valueOf(cr3.getInt(0)));
}
} catch(Exception e){
Log.v("Error", e.toString());
}
return data2;
}
public List<String> countPiutang(){
List<String> data1 = new ArrayList<String>();
List<String> data2 = new ArrayList<String>();
String query1 = "SELECT COUNT(*) as total FROM tb_data_pembeli";
Cursor cr1 = database.rawQuery(query1, null);
cr1.moveToFirst();
int total = cr1.getInt(0);
String query2 = "SELECT id_pembeli FROM tb_data_pembeli ORDER BY nm_pembeli ASC";
Cursor cr2 = database.rawQuery(query2, null);
for(cr2.moveToFirst(); !cr2.isAfterLast(); cr2.moveToNext()) {
data1.add(String.valueOf(cr2.getInt(0)));
}
try{
for(int i = 0; i<total; i++){
String query3 = "SELECT SUM(op.hrg_jual) FROM tb_data_op op, tb_transaksi tr WHERE op.id_op = tr.id_op AND tr.status='1' AND tr.id_pembeli = "+ Integer.valueOf(data1.get(i).toString()) +"";
Cursor cr3 = database.rawQuery(query3, null);
cr3.moveToFirst();
data2.add(i, String.valueOf(cr3.getInt(0)));
}
} catch(Exception e){
Log.v("Error", e.toString());
}
return data2;
}
}
| true
|
055a931dc19e15b31051c2d793bafba96d798030
|
Java
|
mydai/painter
|
/src/com/painter/biz/IUsersBiz.java
|
UTF-8
| 1,476
| 2.59375
| 3
|
[
"MIT"
] |
permissive
|
package com.painter.biz;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.painter.entity.Users;
import com.painter.util.Condition;
public interface IUsersBiz {
/**
* ้่ฟconditionไผ ๅ
ฅๆกไปถๅฎไพ๏ผ่ทๅ็จๆทไฟกๆฏๅ่กจ
* @param condition
* @return List<Users>
*/
public abstract List<Users> getUsersList(Condition condition);
/**
* ้่ฟconditionไผ ๅ
ฅconditionๆกไปถ่ทๅ็จๆทๆปๆฐ
* @param condition
* @return Integer
*/
public abstract int getUsersRecordCount(Condition condition);
/**
* ้่ฟไผ ๅ
ฅ็userไฟกๆฏๅ ้คๆๅฎuser็จๆท
* @param user
* @return Integer
*/
public abstract int delUser(Users user);
/**
* ้่ฟไผ ๅ
ฅๆๅฎuserไฟกๆฏ๏ผๆณจๅuser็จๆท
* @param user
* @return Integer
*/
public abstract int reg(Users user);
/**
* ้่ฟไผ ๅ
ฅuser็nameๅฑๆง,ๆฃๆฅๆฏๅฆๅญๅจ่ฏฅ็จๆท
* @param name
* @return Users
*/
public abstract Users checkName(String name);
/**
* ้่ฟไผ ๅ
ฅuserๅฏน่ฑก,่ฟ่กๅๅฐ้กต้ข็็จๆท็ปๅฝๅ่ฝ
* @param user
* @return Users
*/
public abstract Users login(Users user);
/**
* ้่ฟไผ ๅ
ฅuserๅฏน่ฑก๏ผๆ นๆฎuserๅฏน่ฑก็idๅฑๆงๆฅ่ฏขuser็จๆทไฟกๆฏ
* @param user
* @return Users
*/
public abstract Users findUsersById(Users user);
/**
* ้่ฟไผ ๅ
ฅuserๅฏน่ฑก๏ผๆ นๆฎuserไฟกๆฏๆดๆฐ็จๆทไฟกๆฏ
* @param user
* @return Integer
*/
public abstract int updateUser(Users user);
}
| true
|
4deb098e8f677b53281cc7c767dc5f6b01513181
|
Java
|
Tanneguy/JooN
|
/src/main/java/net/nooj4nlp/controller/CorpusEditorShell/ExportXmlDialog/XmlAnnotationsTextPaneResources.java
|
UTF-8
| 2,804
| 2.875
| 3
|
[] |
no_license
|
package net.nooj4nlp.controller.CorpusEditorShell.ExportXmlDialog;
/**
* Helper class, used for imitating ComponentResourceManager for text pane.
*
*/
public class XmlAnnotationsTextPaneResources
{
private final StringBuilder text;
public XmlAnnotationsTextPaneResources()
{
text = new StringBuilder();
text.append("NooJ's annotations will be represented as XML tags and inserted in the text.");
text.append("\n\n");
text.append("(1) lexical annotations are represented as <LU> XML tags; the lexical properties are represented as XML tag's properties, for instance:");
text.append("\n\n");
text.append("<LU LEMMA=\"eat\" CAT=V TENSE=PR PERSON=2 NUMBER=s>eats</LU>");
text.append("\n\n");
text.append("(2) syntactic annotations are represented exactly as XML tags, for instance:");
text.append("\n\n");
text.append("<DATE>Monday, March 13th</DATE>");
text.append("\n\n");
text.append("(3) The special syntactic annotation TRANS is used to perform translations or replacements in the text.");
text.append("\n\n");
text.append("For instance, <TRANS+EN> will replace the annotated text with the value of the property \"EN\". For instance, if we have the following annotation:");
text.append("\n\n");
text.append("lundi 2 mars,TRANS+EN=Monday, March 2nd");
text.append("\n\n");
text.append("then in the text, all sequences \"lundi 2 mars\" will be replaced with:");
text.append("\n\n");
text.append("<EN>Monday, March 2nd</EN>");
text.append("\n\n");
text.append("OPTIONS:");
text.append("\n\n");
text.append("\"Tag all syntactic annotations\" converts all syntactic annotations into XML tags.");
text.append("\n\n");
text.append("\"Tag only following annotations\": the user must enter the list of the lexical or syntactic annotations to be exported.");
text.append("\n\n");
text.append("If the user enters one or more <TRANS+XXX>, then all the other lexical or syntactic annotations are simply ignored.");
text.append("\n\n");
text.append("\"Export Annotated Text Only\" will only export parts of the text that are annotated with the specified annotations, and simply ignore the remaining text.");
text.append("\n\n");
text.append("(3) In case of ambiguity:");
text.append("\n\n");
text.append("(a) NooJ will give priority to the longest annotations (there could be more than one), and simply ignore shorter ones.");
text.append("\n\n");
text.append("(b) if two or more ambiguous annotations to be exported have the same length, NooJ will export all of them.");
text.append("\n\n");
text.append("(c) NooJ does not manage ambiguous TRANS annotations: if several TRANS annotations occur at the same place with the same length, NooJ will export only one of them.");
}
public StringBuilder getText()
{
return text;
}
}
| true
|
31d926411a722bfe3d921951af166ef14a148c8f
|
Java
|
apache/iceberg
|
/spark/v3.3/spark/src/main/java/org/apache/iceberg/spark/data/vectorized/ArrowVectorAccessors.java
|
UTF-8
| 1,537
| 1.5
| 2
|
[
"Apache-2.0"
] |
permissive
|
/*
* 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.iceberg.spark.data.vectorized;
import org.apache.iceberg.arrow.vectorized.ArrowVectorAccessor;
import org.apache.iceberg.arrow.vectorized.VectorHolder;
import org.apache.spark.sql.types.Decimal;
import org.apache.spark.sql.vectorized.ArrowColumnVector;
import org.apache.spark.sql.vectorized.ColumnarArray;
import org.apache.spark.unsafe.types.UTF8String;
public class ArrowVectorAccessors {
private static final ArrowVectorAccessorFactory factory = new ArrowVectorAccessorFactory();
static ArrowVectorAccessor<Decimal, UTF8String, ColumnarArray, ArrowColumnVector>
getVectorAccessor(VectorHolder holder) {
return factory.getVectorAccessor(holder);
}
private ArrowVectorAccessors() {}
}
| true
|
c835ee07d0680f499a392eeb80fcb00e6bfd527f
|
Java
|
robbiedaves/liftsim
|
/src/main/java/com/robbiedaves/samples/liftsim/FloorUI.java
|
UTF-8
| 624
| 2.921875
| 3
|
[] |
no_license
|
package com.robbiedaves.samples.liftsim;
import java.awt.*;
/**
* Author: Robin Davies
* Date : 11/09/2016
*/
public class FloorUI {
private Floor _floor;
private int _height;
private int _width;
public FloorUI(Floor floor, int height, int width) {
_floor = floor;
_height = height;
_width = width;
}
public void drawFloor(Graphics2D g2d){
LiftLog.log("Drawing floor: " + _floor.floorNumber);
g2d.setColor(new Color(241, 98, 69));
g2d.drawString(_floor.floorNumber.toString(), 1, _height);
g2d.drawLine(1, _height, _width, _height);
}
}
| true
|
0aa6eb0783f613fb38be41d8003776c2a35985a0
|
Java
|
jabagdoshvili/Java-Exam
|
/Jaba-Bagdoshvili-V2/test/StationSquareTest.java
|
UTF-8
| 631
| 2.90625
| 3
|
[] |
no_license
|
import ge.edu.btu.Passenger;
import ge.edu.btu.Train;
import static org.junit.Assert.*;
public class StationSquareTest {
@org.junit.Test
public void main() {
Passenger gio=new Passenger("Gio",true);
Passenger nika=new Passenger("Nika",false);
Passenger jaba=new Passenger("Jaba",true);
Train train=new Train();
assertEquals("Gio Has Ticket, He/She Is Permitted.",train.addPassenger(gio));
assertEquals("Nika Has No Ticket, He/She Is Not Permitted.",train.addPassenger(nika));
assertEquals("Jaba Has Ticket, He/She Is Permitted.",train.addPassenger(jaba));
}
}
| true
|
192e585b73cd7a224e812180f34a38ef4aeb0385
|
Java
|
aby113/easy-java
|
/src/ex06/Student.java
|
UTF-8
| 966
| 3.359375
| 3
|
[] |
no_license
|
package ex06;
public class Student {
public String name;
public int ban;
public int no;
public int kor;
public int eng;
public int math;
public Student(String name, int ban, int no, int kor, int eng, int math) {
super();
this.name = name;
this.ban = ban;
this.no = no;
this.kor = kor;
this.eng = eng;
this.math = math;
}
public Student() {
// TODO Auto-generated constructor stub
}
// ๊ตญ์์ ์ ์ํฉ์ฐ ๋ฐํ
public int getTotal()throws Exception{
return kor + eng + math;
}
// ๊ตญ์์๋ฅผ ๊ณผ๋ชฉ์๋ก ๋๋ ํ๊ท
public float getAverage()throws Exception{
float average = (float) (Math.round((float)(kor + eng + math) / 3 * 10) / 10.0);
return average;
}
// ๋ฉค๋ฒ๋ณ์ + ์ดํฉ + ํ๊ท ๋ฌธ์์ด ์ถ๋ ฅ
public String info()throws Exception{
return this.name +","+ this.ban + ","+this.no + ","+this.kor
+","+ this.eng +","+ this.math+","
+ this.getTotal()+"," + this.getAverage();
}
}
| true
|
3d1d3e0b9e9935001c1e55d1c060b43330e01ecf
|
Java
|
Guillhermegpp/POO
|
/2 bimestre/workspace/Lista12-POO/src/Teste/ServerChat.java
|
ISO-8859-1
| 3,902
| 3.859375
| 4
|
[] |
no_license
|
package Teste;
import java.io.*;
import java.net.*;
import java.util.*;
/**
*
* @author wolmir
*/
public class ServerChat extends Thread {
public static void main(String args[]) {
// instancia o vetor de clientes conectados
clientes = new Vector();
try {
// criando um socket que fica escutando a porta 9090.
ServerSocket s = new ServerSocket(8090);
// Loop principal.
while (true) {
// aguarda algum cliente se conectar. A execuo do
// servidor fica bloqueada na chamada do mtodo accept da
// classe ServerSocket. Quando algum cliente se conectar
// ao servidor, o mtodo desbloqueia e retorna com um
// objeto da classe Socket, que porta da comunicao.
System.out.print("Esperando alguem se conectar...");
Socket conexao = s.accept();
System.out.println(" Conectou!");
// cria uma nova thread para tratar essa conexo
Thread t = new ServerChat(conexao);
t.start();
// voltando ao loop, esperando mais algum se conectar.
}
} catch (IOException e) {
// caso ocorra alguma excesso de E/S, mostre qual foi.
System.out.println("IOException: " + e);
}
}
// Parte que controla as conexes por meio de threads.
// Note que a instanciao est no main.
private static Vector clientes;
// socket deste cliente
private Socket conexao;
// nome deste cliente
private String meuNome;
// construtor que recebe o socket deste cliente
public ServerChat(Socket s) {
conexao = s;
}
// execuo da thread
public void run() {
try {
// objetos que permitem controlar fluxo de comunicao
BufferedReader entrada = new BufferedReader(new InputStreamReader(conexao.getInputStream()));
PrintStream saida = new PrintStream(conexao.getOutputStream());
// primeiramente, espera-se pelo nome do cliente
meuNome = entrada.readLine();
// agora, verifica se string recebida valida, pois
// sem a conexo foi interrompida, a string null.
// Se isso ocorrer, deve-se terminar a execuo.
if (meuNome == null) {
return;
}
// Uma vez que se tem um cliente conectado e conhecido,
// coloca-se fluxo de sada para esse cliente no vetor de
// clientes conectados.
clientes.add(saida);
// clientes objeto compartilhado por vrias threads!
// De acordo com o manual da API, os mtodos so
// sincronizados. Portanto, no h problemas de acessos
// simultneos.
// Loop principal: esperando por alguma string do cliente.
// Quando recebe, envia a todos os conectados at que o
// cliente envie linha em branco.
// Verificar se linha null (conexo interrompida)
// Se no for nula, pode-se compar-la com mtodos string
String linha = entrada.readLine();
while (linha != null && !(linha.trim().equals(""))) {
// reenvia a linha para todos os clientes conectados
sendToAll(saida, " disse: ", linha);
// espera por uma nova linha.
linha = entrada.readLine();
}
// Uma vez que o cliente enviou linha em branco, retira-se
// fluxo de sada do vetor de clientes e fecha-se conexo.
sendToAll(saida, " saiu ", "do chat!");
clientes.remove(saida);
conexao.close();
} catch (IOException e) {
// Caso ocorra alguma excesso de E/S, mostre qual foi.
System.out.println("IOException: " + e);
}
}
// enviar uma mensagem para todos, menos para o prprio
public void sendToAll(PrintStream saida, String acao, String linha) throws IOException {
Enumeration e = clientes.elements();
while (e.hasMoreElements()) {
// obtm o fluxo de sada de um dos clientes
PrintStream chat = (PrintStream) e.nextElement();
// envia para todos, menos para o prprio usurio
if (chat != saida) {
chat.println(meuNome + acao + linha);
}
}
}
}
| true
|
885af123c4bfb2a8f740a9f1b8d8876ffc2be27b
|
Java
|
Sammy30/Codingbat-Java
|
/Array1/maxTriple.java
|
UTF-8
| 375
| 2.765625
| 3
|
[] |
no_license
|
package Array1;
/**
* Created by IntelliJ IDEA.
* User: Matthew M Jenkins
* Date: 2/9/12
* Time: 4:57 AM
*/
public class maxTriple {
public int maxTriple(int[] nums){
int largest = nums[0];
if(nums[nums.length/2] > largest) largest = nums[nums.length/2];
if(nums[nums.length-1] > largest) largest = nums[nums.length-1];
return largest;
}
}
| true
|
a1169ad5abfc567d66d9a0db634a7ab2e25dd845
|
Java
|
priyashanmu/project-2
|
/src/main/java/com/chat/dao/UserBeanDAOImbl.java
|
UTF-8
| 2,440
| 2.171875
| 2
|
[] |
no_license
|
package com.chat.dao;
import java.io.Serializable;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.chat.model.UserAccount;
import com.chat.model.UserRole;
@Repository("userBeanDAO")
public class UserBeanDAOImbl implements UserBeanDAO{
@Autowired
private SessionFactory sessionFactory;
@Transactional(propagation=Propagation.SUPPORTS)
public int insertRow(UserAccount ub) {
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
ub.setEnable(true);
UserRole r=new UserRole();
r.setRoleid(ub.getUserid());
r.setRole_name("ROLE_USER");
r.setRole_username(ub.getUserName());
session.saveOrUpdate(r);
session.saveOrUpdate(ub);
tx.commit();
Serializable id = session.getIdentifier(ub);
session.close();
return (Integer) id;
}
@Transactional(propagation=Propagation.SUPPORTS)
public List getList() {
Session session = sessionFactory.openSession();
@SuppressWarnings("unchecked")
List pList = session.createQuery("from UserAccount").list();
session.close();
return pList;
}
@Transactional(propagation=Propagation.SUPPORTS)
public UserAccount getRowById(int id) {
Session session = sessionFactory.openSession();
UserAccount ub = (UserAccount) session.load(UserAccount.class, id);
return ub;
}
@Transactional(propagation=Propagation.SUPPORTS)
public int updateRow(UserAccount ub) {
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.saveOrUpdate(ub);
tx.commit();
Serializable id = session.getIdentifier(ub);
session.close();
return (Integer) id;
}
@Transactional(propagation=Propagation.SUPPORTS)
public int deleteRow(int id) {
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
UserAccount ub = (UserAccount) session.load(UserAccount.class, id);
session.delete(ub);
tx.commit();
Serializable ids = session.getIdentifier(ub);
session.close();
return (Integer) ids;
}
}
| true
|