blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
410
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
51
| license_type
stringclasses 2
values | repo_name
stringlengths 5
132
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
80
| visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.85k
689M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 22
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 131
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
9.45M
| extension
stringclasses 32
values | content
stringlengths 3
9.45M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
313
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
edf408e5ebdda6cbd5b615da48a9b05e215e4dd3 | ac953b474bb67722e8d890ea0f4d10c3dc9d1a6e | /backend/reserve-check-service/src/main/java/org/egovframe/cloud/reservechecksevice/domain/reserve/ReserveRepositoryCustom.java | 787dff986ae56d589301d8c221ea1f749252cdb2 | [] | no_license | greenn-lab/egovframe-msa-edu | 00fbeab4040040f6e1f955fa17fe5e199dec92a5 | 02e03dac79ebb3da42788430f25d196d8a7f83f7 | refs/heads/main | 2023-09-05T16:33:17.528244 | 2021-11-15T06:25:10 | 2021-11-15T06:25:10 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,737 | java | package org.egovframe.cloud.reservechecksevice.domain.reserve;
import org.egovframe.cloud.common.dto.RequestDto;
import org.egovframe.cloud.reservechecksevice.api.reserve.dto.ReserveRequestDto;
import org.springframework.data.domain.Pageable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
/**
* org.egovframe.cloud.reservechecksevice.domain.reserve.ReserveRepositoryCustom
*
* 예약 도메인 custom Repository interface
*
* @author 표준프레임워크센터 shinmj
* @version 1.0
* @since 2021/09/15
*
* <pre>
* << 개정이력(Modification Information) >>
*
* 수정일 수정자 수정내용
* ---------- -------- ---------------------------
* 2021/09/15 shinmj 최초 생성
* </pre>
*/
public interface ReserveRepositoryCustom {
Flux<Reserve> search(ReserveRequestDto requestDto, Pageable pageable);
Mono<Long> searchCount(ReserveRequestDto requestDto, Pageable pageable);
Mono<Reserve> findReserveById(String reserveId);
Flux<Reserve> searchForUser(ReserveRequestDto requestDto, Pageable pageable, String userId);
Mono<Long> searchCountForUser(ReserveRequestDto requestDto, Pageable pageable, String userId);
Mono<Reserve> loadRelations(Reserve reserve);
Flux<Reserve> findAllByReserveDate(Long reserveItemId, LocalDateTime startDate, LocalDateTime endDate);
Flux<Reserve> findAllByReserveDateWithoutSelf(String reserveId, Long reserveItemId, LocalDateTime startDate, LocalDateTime endDate);
Mono<Long> findAllByReserveDateWithoutSelfCount(String reserveId, Long reserveItemId, LocalDateTime startDate, LocalDateTime endDate);
Mono<Reserve> insert(Reserve reserve);
}
| [
"[email protected]"
] | |
149797258626d2ab2475e5c7fd310fd1a4ab3a9f | 8ab737c98dda9e4480366bd4d6f32ccade26ff20 | /src/jp/co/nskint/uq/pd/signage/model/xml/DirectionType.java | 0094567693d0c14f10187e182cdd027f29be24eb | [] | no_license | munehiro-takahashi/uq-signage | 5eda72bace1d3702432a2468b6df1895bcfbe199 | 84dcf281718a21fc8aab89396bd10b1f77c7f72e | refs/heads/master | 2021-01-22T06:44:33.062679 | 2012-09-01T17:33:08 | 2012-09-01T17:33:08 | 35,258,883 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,721 | java | //
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 in JDK 6
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2012.02.09 at 07:06:54 �ߌ� JST
//
package jp.co.nskint.uq.pd.signage.model.xml;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for DirectionType.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="DirectionType">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="up"/>
* <enumeration value="down"/>
* <enumeration value="left"/>
* <enumeration value="right"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlType(name = "DirectionType")
@XmlEnum
public enum DirectionType {
@XmlEnumValue("up")
UP("up"),
@XmlEnumValue("down")
DOWN("down"),
@XmlEnumValue("left")
LEFT("left"),
@XmlEnumValue("right")
RIGHT("right");
private final String value;
DirectionType(String v) {
value = v;
}
public String value() {
return value;
}
public static DirectionType fromValue(String v) {
for (DirectionType c: DirectionType.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}
}
| [
"[email protected]@54564b0a-3131-6a6e-b261-5d0d787781db"
] | [email protected]@54564b0a-3131-6a6e-b261-5d0d787781db |
d0801ec933f3bf8028b39770d921a59cf8e24d6a | 0d4edfbd462ed72da9d1e2ac4bfef63d40db2990 | /app/src/main/java/com/dvc/mybilibili/mvp/presenter/activity/LoginPresenter.java | 12ca248b98f837a87c1821bbf7b900527a431c13 | [] | no_license | dvc890/MyBilibili | 1fc7e0a0d5917fb12a7efed8aebfd9030db7ff9f | 0483e90e6fbf42905b8aff4cbccbaeb95c733712 | refs/heads/master | 2020-05-24T22:49:02.383357 | 2019-11-23T01:14:14 | 2019-11-23T01:14:14 | 187,502,297 | 31 | 3 | null | null | null | null | UTF-8 | Java | false | false | 2,238 | java | package com.dvc.mybilibili.mvp.presenter.activity;
import android.arch.lifecycle.Lifecycle;
import android.content.Context;
import com.dvc.base.di.ApplicationContext;
import com.dvc.base.utils.RxSchedulersHelper;
import com.dvc.mybilibili.app.retrofit2.callback.ObserverCallback;
import com.dvc.mybilibili.mvp.model.DataManager;
import com.dvc.mybilibili.mvp.model.api.exception.BiliApiException;
import com.dvc.mybilibili.mvp.model.api.service.account.entity.LoginInfo;
import com.dvc.mybilibili.mvp.presenter.MyMvpBasePresenter;
import com.dvc.mybilibili.mvp.ui.activity.LoginView;
import com.trello.rxlifecycle2.LifecycleProvider;
import javax.inject.Inject;
public class LoginPresenter extends MyMvpBasePresenter<LoginView> {
@Inject
public LoginPresenter(@ApplicationContext Context context, DataManager dataManager, LifecycleProvider<Lifecycle.Event> provider) {
super(context, dataManager, provider);
}
public LifecycleProvider<Lifecycle.Event> getProvider() {
return this.provider;
}
public void login(String name, String password) {
this.dataManager.getApiHelper().getKey(false)
.compose(RxSchedulersHelper.AllioThread())
.subscribe(authKey -> {
this.dataManager.getApiHelper().loginV3(name,authKey.encryptPassword(password))
.compose(RxSchedulersHelper.ioAndMainThread())
.compose(provider.bindUntilEvent(Lifecycle.Event.ON_DESTROY))
.subscribe(new ObserverCallback<LoginInfo>() {
@Override
public void onSuccess(LoginInfo loginInfo) {
dataManager.getUser().loadToLoginInfo(loginInfo);
ifViewAttached(view -> view.loginCompleted(loginInfo));
}
@Override
public void onError(BiliApiException apiException, int code) {
ifViewAttached(view -> view.loginFailed(apiException));
}
});
});
}
}
| [
"[email protected]"
] | |
1d79139fd0c49ee453d8458094dffd7fde6154fc | e3f01452b33f785f136e55e56b0f03b1545979ee | /aws-java-sdk-appmesh/src/main/java/com/amazonaws/services/appmesh/model/transform/VirtualGatewayTlsValidationContextMarshaller.java | 80ac6be34728df467ef01067b5fa649db52a79c3 | [
"Apache-2.0"
] | permissive | kundan59/aws-sdk-java | 4f7ba8f6b8fcad155e25e5b11f9c9a28ec99d6ac | 00f289a50d8c910830f172599d6d0c6b034f6221 | refs/heads/master | 2023-02-26T13:01:37.888044 | 2021-01-29T21:48:34 | 2021-01-29T21:48:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,123 | java | /*
* Copyright 2016-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.appmesh.model.transform;
import javax.annotation.Generated;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.appmesh.model.*;
import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;
/**
* VirtualGatewayTlsValidationContextMarshaller
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class VirtualGatewayTlsValidationContextMarshaller {
private static final MarshallingInfo<StructuredPojo> TRUST_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
.marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("trust").build();
private static final VirtualGatewayTlsValidationContextMarshaller instance = new VirtualGatewayTlsValidationContextMarshaller();
public static VirtualGatewayTlsValidationContextMarshaller getInstance() {
return instance;
}
/**
* Marshall the given parameter object.
*/
public void marshall(VirtualGatewayTlsValidationContext virtualGatewayTlsValidationContext, ProtocolMarshaller protocolMarshaller) {
if (virtualGatewayTlsValidationContext == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(virtualGatewayTlsValidationContext.getTrust(), TRUST_BINDING);
} catch (Exception e) {
throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
}
}
}
| [
""
] | |
31fc272d98c035caf428f0c59205a92468b3d315 | 9e748e5af99ad462949f5a125155d2cbf5c319a6 | /src/main/java/denominator/discoverydns/DiscoveryDNSTarget.java | b6b274a27bd40c8b2cd2521f74a183572cdde6d4 | [] | no_license | discoverydns/denominator-discoverydns | de33d67ae59f18b30d6e5cf8d25a1408838272ef | 128d8518970603d47fe0cd813fb4c1a893b05daf | refs/heads/master | 2020-05-30T03:58:32.551378 | 2015-08-14T02:00:06 | 2015-08-14T02:00:06 | 32,360,777 | 3 | 1 | null | null | null | null | UTF-8 | Java | false | false | 854 | java | package denominator.discoverydns;
import javax.inject.Inject;
import denominator.Denominator.Version;
import denominator.Provider;
import feign.Request;
import feign.RequestTemplate;
import feign.Target;
final class DiscoveryDNSTarget implements Target<DiscoveryDNS> {
private static final String CLIENT_ID = "Denominator " + Version.INSTANCE;
private final Provider provider;
@Inject
DiscoveryDNSTarget(Provider provider) {
this.provider = provider;
}
@Override
public Class<DiscoveryDNS> type() {
return DiscoveryDNS.class;
}
@Override
public String name() {
return provider.name();
}
@Override
public String url() {
return provider.url();
}
@Override
public Request apply(RequestTemplate in) {
in.insert(0, url());
in.header("X-Requested-By", CLIENT_ID);
return in.request();
}
}
| [
"[email protected]"
] | |
a95ce53d91d1e7c24883e75b795df5b32eebf0d7 | a0964e2c3e6a21c57db3d88d6b76eba9415a19b3 | /common/src/main/java/com/keemono/common/utils/dozer/DozerI.java | 0568aea8f33c7f6b068fc3b0efc53a80a55e2446 | [] | no_license | duardito/keemono | 70f719b46903413d7349df0e32de8fb2f065af11 | 4a9324ae805f8186780210283760080f4b3ca3cd | refs/heads/master | 2020-04-06T07:07:02.120617 | 2015-03-12T17:19:53 | 2015-03-12T17:19:53 | 28,585,066 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 339 | java | package com.keemono.common.utils.dozer;
import org.dozer.Mapper;
import java.util.List;
/**
* Created by edu on 19/01/2015.
*/
public interface DozerI<T> {
public <M> M map (final Object sourceObject, final Class<M> destType);
public <T, U> List<U> map(final Mapper mapper, final List<T> source, final Class<U> destType);
}
| [
"[email protected]"
] | |
d746cbfe15dd6adb3be1086616df730f6a5016a1 | 6e2faaa40704d23ff112dbab6475a94bea03f36e | /src/main/java/org/duohuo/paper/manager/PageManager.java | 7b33bfc8f620b3ac82b454868a8892ae37e0eb8f | [
"MIT"
] | permissive | lwolvej/paper-project | 05bc53b661d04260e95a915c337e86a16a0875c4 | 96c1729e0aacb40b80408fdbf2b706fe986103dd | refs/heads/master | 2023-08-05T00:36:18.853889 | 2019-05-29T18:01:36 | 2019-05-29T18:01:36 | 172,909,632 | 16 | 3 | MIT | 2023-07-21T12:34:44 | 2019-02-27T12:16:30 | Java | UTF-8 | Java | false | false | 981 | java | package org.duohuo.paper.manager;
import org.duohuo.paper.constants.PageConstant;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;
@Component("pageManager")
public class PageManager {
public PageRequest pageRequestCreate(final Integer pageNum, final Boolean ifDesc, final String... sortBy) {
Sort sort;
if (ifDesc) {
if (sortBy.length == 2) {
sort = Sort.by(Sort.Order.desc(sortBy[0]), Sort.Order.desc(sortBy[1]));
} else {
sort = Sort.by(Sort.Order.desc(sortBy[0]));
}
} else {
if (sortBy.length == 2) {
sort = Sort.by(Sort.Order.asc(sortBy[0]), Sort.Order.asc(sortBy[1]));
} else {
sort = Sort.by(Sort.Order.asc(sortBy[0]));
}
}
return PageRequest.of(pageNum, PageConstant.PAGE_SIZE, sort);
}
}
| [
"[email protected]"
] | |
79b27f41a46a1e1b1b734d69f66d30109e20ad42 | 9c11efed24e6eac71320e18906cf03af5cbace1e | /backend/src/test/java/de/slackspace/rmanager/gameengine/service/CabinetServiceTest.java | 5a18379fa6db92d3f0dfc972ca2533c7abb67247 | [
"Apache-2.0"
] | permissive | cternes/R-Manager | 6772c8e69fcd4a9e9c496f3731efe272ea34f0a2 | d484fdfca1beb115d8362f254814ca7b327965b5 | refs/heads/master | 2020-06-05T19:40:47.927589 | 2015-09-04T18:56:53 | 2015-09-04T18:56:53 | 33,321,431 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,311 | java | package de.slackspace.rmanager.gameengine.service;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertThat;
import java.util.List;
import org.junit.Test;
import de.slackspace.rmanager.gameengine.domain.Cabinet;
import de.slackspace.rmanager.gameengine.domain.DepartmentType;
public class CabinetServiceTest {
CabinetService cut = new CabinetService();
@Test
public void whenCreateKitchenCabinetShouldReturnCabinet() {
List<Cabinet> cabinets = cut.createCabinet(DepartmentType.Kitchen);
assertThat(cabinets, hasSize(10));
}
@Test
public void whenCreateDiningHallCabinetShouldReturnCabinet() {
List<Cabinet> cabinets = cut.createCabinet(DepartmentType.Dininghall);
assertThat(cabinets, hasSize(9));
}
@Test
public void whenCreateLaundryCabinetShouldReturnCabinet() {
List<Cabinet> cabinets = cut.createCabinet(DepartmentType.Laundry);
assertThat(cabinets, hasSize(10));
}
@Test
public void whenCreateFacilitiesCabinetShouldReturnCabinet() {
List<Cabinet> cabinets = cut.createCabinet(DepartmentType.Facilities);
assertThat(cabinets, hasSize(7));
}
@Test
public void whenCreateReeferCabinetShouldReturnCabinet() {
List<Cabinet> cabinets = cut.createCabinet(DepartmentType.Reefer);
assertThat(cabinets, hasSize(10));
}
}
| [
"[email protected]"
] | |
7dacb4c9f86000cdc14a5f5789f011b34663cc5b | 17999f59adae137d2a9366e3db2a8a91b8509fca | /src/main/java/org/killbill/billing/plugin/adyen/client/payment/builder/ModificationRequestBuilder.java | 597c208a8fb293fdb42345a33320c21ce88cd633 | [
"Apache-2.0"
] | permissive | BLangendorf/killbill-adyen-plugin | 731016e8294824cdf5163cbdf0e7910715d38ef3 | fcae848332f1ddfafed6a0586b7f0cd6e0a7dda0 | refs/heads/master | 2021-01-18T13:10:15.438166 | 2016-03-01T22:29:37 | 2016-03-01T22:29:37 | 39,011,192 | 0 | 0 | null | 2015-07-13T12:38:32 | 2015-07-13T12:38:31 | null | UTF-8 | Java | false | false | 2,626 | java | /*
* Copyright 2014 Groupon, Inc
*
* Groupon 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.killbill.billing.plugin.adyen.client.payment.builder;
import java.util.List;
import org.killbill.adyen.common.Amount;
import org.killbill.adyen.payment.AnyType2AnyTypeMap;
import org.killbill.adyen.payment.ModificationRequest;
import org.killbill.billing.plugin.adyen.client.model.SplitSettlementData;
public class ModificationRequestBuilder extends RequestBuilder<ModificationRequest> {
public ModificationRequestBuilder() {
super(new ModificationRequest());
}
public ModificationRequestBuilder withOriginalReference(final String value) {
request.setOriginalReference(value);
return this;
}
public ModificationRequestBuilder withMerchantAccount(final String value) {
request.setMerchantAccount(value);
return this;
}
public ModificationRequestBuilder withAuthorisationCode(final String value) {
request.setAuthorisationCode(value);
return this;
}
public ModificationRequestBuilder withAmount(final String currency, final Long value) {
if (value != null) {
final Amount amount = new Amount();
amount.setCurrency(currency);
amount.setValue(value);
return withAmount(amount);
}
return this;
}
public ModificationRequestBuilder withAmount(final Amount amount) {
request.setModificationAmount(amount);
return this;
}
public ModificationRequestBuilder withSplitSettlementData(final SplitSettlementData splitSettlementData) {
final List<AnyType2AnyTypeMap.Entry> entries = new SplitSettlementParamsBuilder().createEntriesFrom(splitSettlementData);
addAdditionalData(entries);
return this;
}
@Override
protected List<AnyType2AnyTypeMap.Entry> getAdditionalData() {
if (request.getAdditionalData() == null) {
request.setAdditionalData(new AnyType2AnyTypeMap());
}
return request.getAdditionalData().getEntry();
}
}
| [
"[email protected]"
] | |
52a18f00cf7d671ebdfecc1c3bd75758b9dd46d6 | cb47a69eb202feae227358af2493efe9c35d0cf6 | /spring-cloud/springcloud-sso/sso/auth-center-master/auth-server/auth-server-core/src/main/java/com/lingchaomin/auth/server/core/role/entity/Authorization.java | 3df48ff6007461ec1e386b7a0b8b3d2e4a22c41d | [
"Apache-2.0"
] | permissive | WCry/demo | e4f6ee469e39e9a96e9deec2724eb89d642830b5 | 5801b12371a1beb610328a8b83a056276427817d | refs/heads/master | 2023-05-28T14:42:29.175634 | 2021-06-14T14:06:43 | 2021-06-14T14:06:43 | 266,535,701 | 2 | 1 | Apache-2.0 | 2020-10-21T01:03:55 | 2020-05-24T12:24:51 | Java | UTF-8 | Java | false | false | 727 | java | package com.lingchaomin.auth.server.core.role.entity;
import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
/**
* @author minlingchao
* @version 1.0
* @date 2017/2/20 下午9:35
* @description 授权信息
*/
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Authorization implements Serializable {
private Long id;
private Date gmtCreate;
private Date gmtModified;
/**
* 用户id
*/
private Long userId;
/**
* 应用id
*/
private Long appId;
/**
* 权限ids
*/
private String roleIds;
}
| [
"[email protected]"
] | |
ee4e7e4b05ff19bb410de74db6ca3e0a572b42cf | 96181829095d8fbd56b91116c553f1d77a105dc5 | /Java/SelectionSort/src/SelectionSortApp.java | 97fdfd11fb857c2910e074c712be29582d02d47b | [] | no_license | curatorcorpus/FirstProgramming | ef94f345529ad8a3bec0e5f8f1d9dcdf47725c5f | a119709b748f272a0104e58258b4326f1c90460f | refs/heads/master | 2021-06-19T15:25:52.398710 | 2017-07-11T09:36:44 | 2017-07-11T09:36:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 481 | java | import javax.swing.*;
public class SelectionSortApp {
public static void main(String[] args){
// create main window
JFrame mainWindow = new JFrame("Selection Sort App");
// main window settings
mainWindow.getContentPane().add(new SelectionSortPanel());
mainWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainWindow.setExtendedState(mainWindow.getExtendedState()|JFrame.MAXIMIZED_BOTH );
mainWindow.pack();
mainWindow.setVisible(true);
}
}
| [
"[email protected]"
] | |
7181bba551a5321892c49860539e433e488abd0c | 4cf11cf0b5eefc0140589b2b1708855fc0f5c861 | /Goosegame/src/goosegame/Board.java | ac616f47147f417d17418f444974acd6feec039e | [] | no_license | fouadMd/java | 4549425afd2444468963e8a9ae589596156bb2aa | 081ab40498cce4fe8fc71b4843054d46147c9ce6 | refs/heads/master | 2023-04-25T16:50:21.978480 | 2021-05-20T10:18:55 | 2021-05-20T10:18:55 | 358,635,639 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 869 | java | package goosegame;
/**
* The representation of Board
*
* @author Medjahed Ainouch
* @version 1.0
*/
public abstract class Board{
/*the number of cells in the board*/
protected final int NB_OF_CELLS ;
/*the cells in the board*/
protected Cell [] theCells;
/**
*build a board
*@param nbofcells is the number of cells
*/
public Board (int nbofcells){
this.NB_OF_CELLS= nbofcells;
this.theCells= new Cell[nbofcells];
this.theCells[0]=new StartCell(0);
this.initBoard();
}
/**
*get cell which the index is n
*@param n is the number of cell
*@return nth Cell
*/
public Cell getCell(int n){
return this.theCells[n];
}
/**
*initialise the board
*/
protected abstract void initBoard();
/**
*Return the number of cells in the board
*@return the number of cells in the board
*/
public int nbOfCells(){
return this.NB_OF_CELLS;
}
}
| [
"[email protected]"
] | |
e04128c05ec3a772fc164135b43aeb556596e33f | f4bfa81d63a6cd596854be74dcce9d4f63f8390f | /src/main/java/com/watership/repository/CategoryRepository.java | 786976bc6d65c983c32d6aa2b869f44fda67cbbe | [] | no_license | magnusfiorepalm/watership | 962faa972b1773f749d153c529e3bd71a56798d0 | aed16fa9731c36304315bfc62dd06e2eb4670b64 | refs/heads/master | 2020-12-28T21:51:23.464132 | 2016-09-08T02:38:12 | 2016-09-08T02:38:12 | 46,250,715 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 237 | java | package com.watership.repository;
import org.springframework.data.repository.PagingAndSortingRepository;
import com.watership.model.Category;
public interface CategoryRepository extends PagingAndSortingRepository<Category, Long> {
}
| [
"[email protected]"
] | |
dc879336ad8099c286e0d241e19f8307317c161a | 35e4aef9b8861ed439bd3695683933a0db52b630 | /app/src/main/java/com/storm/cftest/base/Question.java | 32576ba4b1875d2be374ced07757b481dc53de2c | [] | no_license | acmlgogo/one_kotlin | 4a06a2870813192d5b0a5c59f369b317aabc9aab | 9d5f6cf71f3f24aaf6d5d8a5cd260751d2907b29 | refs/heads/master | 2021-01-13T07:12:09.987566 | 2019-06-24T09:51:01 | 2019-06-24T09:51:01 | 95,061,710 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 42,962 | java | package com.storm.cftest.base;
import java.util.List;
/**
* 作者：程峰 on 2017/6/12
* 邮箱：[email protected]
* github :https://github.com/acmlgogo
*/
public class Question {
/**
* res : 0
* data : {"question_id":"1593","question_title":"美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","question_content":"美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？ ","answer_title":"","answer_content":"合同法关于赠与礼物有相关的规定，其中当受赠人严重侵害赠与人或赠与人近亲属，赠与可以被撤销。<br>\r\n <br>\r\n美国队长不但包庇杀害赠与人的凶手冬兵，还用这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情，很明显符合撤销赠与的条件。<br>\r\n <br>\r\n大家都觉得分手后找女生要回礼物的行为很low，但如果是女生出轨/家暴在先，那么男生要回礼物是有法律依据的。<br>\r\n <br>\r\n\u201c队长如果主张和霍华德斯塔克只是加工承揽关系，并能提供相关证据，那托尼就无权要求队长返还盾牌了。\u201d<br>\r\n <br>\r\n其实钢铁侠的爹在这里确实是加工承揽的关系的一方。霍华德斯塔克创建的斯塔克工业是美军的供应商，霍华德本人是\u201c超级士兵计划\u201d的核心科学家，这面盾作为武器也是霍华德提供的产品。但是，这个\u201c超级士兵计划\u201d是美国军方的项目，霍华德作为民间科学家积极参与，为国效力。这属于政府搭台，民企唱戏，其中霍华德是项目乙方，美国军方才是甲方爸爸，美队本人最多算是接受培训的员工。所以这盾牌自然属于美国军方财产，只是被作为武器下发到美队手中。后来，美队由于职务变动由美军宣传部门调动到了复仇者部门，他的盾和制服想来也是一并调动。<br>\r\n <br>\r\n在复仇者的内战中，美队由于反抗政府的监管，显然已经不再担任复仇者组织的领导职务。因此，钢铁侠作为与政府合作的一方，在法理上可以代表复仇者索要部门财产，这就跟警察被革职的时候要上交警枪和徽章一样。实际上，美队敲坏了钢铁侠的装甲，属于毁坏军事物资，也是违法并且要赔偿的。<br>\r\n <br>\r\n作为佐证，在美队后面的漫画中就有一集讲他被迫退役，离开时就向政府上交了盾和制服。<br>\r\n <br>\r\n如果再深入一些讨论，我们还可以继续探讨，金刚狼的骨头是他的骨头吗？<br>\r\n因为加拿大政府利用金刚狼做实验，在他骨骼中注入昂贵的振金。那么，这些振金属于谁所有呢？<br>\r\n <br>\r\n在现实中，以医疗为目的的植入设备的所有权都归患者。比如心脏搭桥手术里的桥，隆胸手术里的硅胶还有假牙等。即使后来这些植入设备被取出后，他们的所属权依然归于患者。（金牙还可以回炉，这硅胶可能只能当狗玩具了）所以，如果金刚狼骨折了，医院打的金属板是应该归他所有。<br>\r\n <br>\r\n但是，金刚狼在这里是以军人身份，受命完成Weapon X计划，在开始前应当了解并签署了相关文件。那么，军方是否就有权回收振金呢？<br>\r\n <br>\r\n根据电影里后面的内容，金刚狼在实验过程中显然处于被洗脑的状态，在法律上属于限制责任能力人，所签署的合同并没有法律效力。另外，即便军方能够证明他当时是完全清醒并自愿也不行。因为取出骨头会让他丧命，法院是不会支持立即执行的。或许在他死后，军方会有机会打官司争一争。<br>\r\n <br>\r\n不过，考虑到金刚狼在核弹中都能存活的恐怖生命力，军方恐怕需要很好的耐心，等上一阵子了。届时，如果他的第N代重孙对这堆骨头没兴趣，说不定连法院都不用去了。<br>\r\n ","question_makettime":"2017-01-07 08:00:00","recommend_flag":"0","charge_edt":"责任编辑：向可","charge_email":"[email protected]","last_update_date":"2017-03-30 15:31:07","web_url":"http://m.wufazhuce.com/question/1593","read_num":"45900","guide_word":"这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","audio":"","anchor":"","cover":"","content_bgcolor":"#80ACE1","cover_media_type":"0","cover_media_file":"","start_video":"","copyright":"","answerer":{"user_id":"7566818","user_name":"温义飞","desc":"有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。 ","wb_name":"@Blake老实人","is_settled":"0","settled_type":"0","summary":"温义飞，ONE热门回答者。","fans_total":"353","web_url":"http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1"},"asker":{"user_id":"0","user_name":"lilizhou","web_url":"http://image.wufazhuce.com/placeholder-author-avatar.png","summary":"","desc":"","is_settled":"","settled_type":"","fans_total":"","wb_name":""},"author_list":[{"user_id":"7566818","user_name":"温义飞","desc":"有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。 ","wb_name":"@Blake老实人","is_settled":"0","settled_type":"0","summary":"温义飞，ONE热门回答者。","fans_total":"353","web_url":"http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1"}],"asker_list":[{"user_id":"0","user_name":"lilizhou","web_url":"http://image.wufazhuce.com/placeholder-author-avatar.png","summary":"","desc":"","is_settled":"","settled_type":"","fans_total":"","wb_name":""}],"next_id":"1592","previous_id":"1590","tag_list":[],"share_list":{"wx":{"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=singlemessage","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""},"wx_timeline":{"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=timeline","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""},"weibo":{"title":"ONE一个《问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？》 文/温义飞： 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。 阅读全文：http://m.wufazhuce.com/question/1593?channel=weibo 下载ONE一个APP:http://weibo.com/p/100404157874","desc":"","link":"http://m.wufazhuce.com/question/1593?channel=weibo","imgUrl":"","audio":""},"qq":{"title":"美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=qq","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""}},"praisenum":407,"sharenum":209,"commentnum":144}
*/
private int res;
private DataBean data;
public int getRes() {
return res;
}
public void setRes(int res) {
this.res = res;
}
public DataBean getData() {
return data;
}
public void setData(DataBean data) {
this.data = data;
}
public static class DataBean {
/**
* question_id : 1593
* question_title : 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？
* question_content : 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？
* answer_title :
* answer_content : 合同法关于赠与礼物有相关的规定，其中当受赠人严重侵害赠与人或赠与人近亲属，赠与可以被撤销。<br>
<br>
美国队长不但包庇杀害赠与人的凶手冬兵，还用这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情，很明显符合撤销赠与的条件。<br>
<br>
大家都觉得分手后找女生要回礼物的行为很low，但如果是女生出轨/家暴在先，那么男生要回礼物是有法律依据的。<br>
<br>
“队长如果主张和霍华德斯塔克只是加工承揽关系，并能提供相关证据，那托尼就无权要求队长返还盾牌了。”<br>
<br>
其实钢铁侠的爹在这里确实是加工承揽的关系的一方。霍华德斯塔克创建的斯塔克工业是美军的供应商，霍华德本人是“超级士兵计划”的核心科学家，这面盾作为武器也是霍华德提供的产品。但是，这个“超级士兵计划”是美国军方的项目，霍华德作为民间科学家积极参与，为国效力。这属于政府搭台，民企唱戏，其中霍华德是项目乙方，美国军方才是甲方爸爸，美队本人最多算是接受培训的员工。所以这盾牌自然属于美国军方财产，只是被作为武器下发到美队手中。后来，美队由于职务变动由美军宣传部门调动到了复仇者部门，他的盾和制服想来也是一并调动。<br>
<br>
在复仇者的内战中，美队由于反抗政府的监管，显然已经不再担任复仇者组织的领导职务。因此，钢铁侠作为与政府合作的一方，在法理上可以代表复仇者索要部门财产，这就跟警察被革职的时候要上交警枪和徽章一样。实际上，美队敲坏了钢铁侠的装甲，属于毁坏军事物资，也是违法并且要赔偿的。<br>
<br>
作为佐证，在美队后面的漫画中就有一集讲他被迫退役，离开时就向政府上交了盾和制服。<br>
<br>
如果再深入一些讨论，我们还可以继续探讨，金刚狼的骨头是他的骨头吗？<br>
因为加拿大政府利用金刚狼做实验，在他骨骼中注入昂贵的振金。那么，这些振金属于谁所有呢？<br>
<br>
在现实中，以医疗为目的的植入设备的所有权都归患者。比如心脏搭桥手术里的桥，隆胸手术里的硅胶还有假牙等。即使后来这些植入设备被取出后，他们的所属权依然归于患者。（金牙还可以回炉，这硅胶可能只能当狗玩具了）所以，如果金刚狼骨折了，医院打的金属板是应该归他所有。<br>
<br>
但是，金刚狼在这里是以军人身份，受命完成Weapon X计划，在开始前应当了解并签署了相关文件。那么，军方是否就有权回收振金呢？<br>
<br>
根据电影里后面的内容，金刚狼在实验过程中显然处于被洗脑的状态，在法律上属于限制责任能力人，所签署的合同并没有法律效力。另外，即便军方能够证明他当时是完全清醒并自愿也不行。因为取出骨头会让他丧命，法院是不会支持立即执行的。或许在他死后，军方会有机会打官司争一争。<br>
<br>
不过，考虑到金刚狼在核弹中都能存活的恐怖生命力，军方恐怕需要很好的耐心，等上一阵子了。届时，如果他的第N代重孙对这堆骨头没兴趣，说不定连法院都不用去了。<br>
* question_makettime : 2017-01-07 08:00:00
* recommend_flag : 0
* charge_edt : 责任编辑：向可
* charge_email : [email protected]
* last_update_date : 2017-03-30 15:31:07
* web_url : http://m.wufazhuce.com/question/1593
* read_num : 45900
* guide_word : 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。
* audio :
* anchor :
* cover :
* content_bgcolor : #80ACE1
* cover_media_type : 0
* cover_media_file :
* start_video :
* copyright :
* answerer : {"user_id":"7566818","user_name":"温义飞","desc":"有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。 ","wb_name":"@Blake老实人","is_settled":"0","settled_type":"0","summary":"温义飞，ONE热门回答者。","fans_total":"353","web_url":"http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1"}
* asker : {"user_id":"0","user_name":"lilizhou","web_url":"http://image.wufazhuce.com/placeholder-author-avatar.png","summary":"","desc":"","is_settled":"","settled_type":"","fans_total":"","wb_name":""}
* author_list : [{"user_id":"7566818","user_name":"温义飞","desc":"有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。 ","wb_name":"@Blake老实人","is_settled":"0","settled_type":"0","summary":"温义飞，ONE热门回答者。","fans_total":"353","web_url":"http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1"}]
* asker_list : [{"user_id":"0","user_name":"lilizhou","web_url":"http://image.wufazhuce.com/placeholder-author-avatar.png","summary":"","desc":"","is_settled":"","settled_type":"","fans_total":"","wb_name":""}]
* next_id : 1592
* previous_id : 1590
* tag_list : []
* share_list : {"wx":{"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=singlemessage","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""},"wx_timeline":{"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=timeline","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""},"weibo":{"title":"ONE一个《问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？》 文/温义飞： 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。 阅读全文：http://m.wufazhuce.com/question/1593?channel=weibo 下载ONE一个APP:http://weibo.com/p/100404157874","desc":"","link":"http://m.wufazhuce.com/question/1593?channel=weibo","imgUrl":"","audio":""},"qq":{"title":"美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=qq","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""}}
* praisenum : 407
* sharenum : 209
* commentnum : 144
*/
private String question_id;
private String question_title;
private String question_content;
private String answer_title;
private String answer_content;
private String question_makettime;
private String recommend_flag;
private String charge_edt;
private String charge_email;
private String last_update_date;
private String web_url;
private String read_num;
private String guide_word;
private String audio;
private String anchor;
private String cover;
private String content_bgcolor;
private String cover_media_type;
private String cover_media_file;
private String start_video;
private String copyright;
private AnswererBean answerer;
private AskerBean asker;
private String next_id;
private String previous_id;
private ShareListBean share_list;
private int praisenum;
private int sharenum;
private int commentnum;
private List<AuthorListBean> author_list;
private List<AskerListBean> asker_list;
private List<?> tag_list;
public String getQuestion_id() {
return question_id;
}
public void setQuestion_id(String question_id) {
this.question_id = question_id;
}
public String getQuestion_title() {
return question_title;
}
public void setQuestion_title(String question_title) {
this.question_title = question_title;
}
public String getQuestion_content() {
return question_content;
}
public void setQuestion_content(String question_content) {
this.question_content = question_content;
}
public String getAnswer_title() {
return answer_title;
}
public void setAnswer_title(String answer_title) {
this.answer_title = answer_title;
}
public String getAnswer_content() {
return answer_content;
}
public void setAnswer_content(String answer_content) {
this.answer_content = answer_content;
}
public String getQuestion_makettime() {
return question_makettime;
}
public void setQuestion_makettime(String question_makettime) {
this.question_makettime = question_makettime;
}
public String getRecommend_flag() {
return recommend_flag;
}
public void setRecommend_flag(String recommend_flag) {
this.recommend_flag = recommend_flag;
}
public String getCharge_edt() {
return charge_edt;
}
public void setCharge_edt(String charge_edt) {
this.charge_edt = charge_edt;
}
public String getCharge_email() {
return charge_email;
}
public void setCharge_email(String charge_email) {
this.charge_email = charge_email;
}
public String getLast_update_date() {
return last_update_date;
}
public void setLast_update_date(String last_update_date) {
this.last_update_date = last_update_date;
}
public String getWeb_url() {
return web_url;
}
public void setWeb_url(String web_url) {
this.web_url = web_url;
}
public String getRead_num() {
return read_num;
}
public void setRead_num(String read_num) {
this.read_num = read_num;
}
public String getGuide_word() {
return guide_word;
}
public void setGuide_word(String guide_word) {
this.guide_word = guide_word;
}
public String getAudio() {
return audio;
}
public void setAudio(String audio) {
this.audio = audio;
}
public String getAnchor() {
return anchor;
}
public void setAnchor(String anchor) {
this.anchor = anchor;
}
public String getCover() {
return cover;
}
public void setCover(String cover) {
this.cover = cover;
}
public String getContent_bgcolor() {
return content_bgcolor;
}
public void setContent_bgcolor(String content_bgcolor) {
this.content_bgcolor = content_bgcolor;
}
public String getCover_media_type() {
return cover_media_type;
}
public void setCover_media_type(String cover_media_type) {
this.cover_media_type = cover_media_type;
}
public String getCover_media_file() {
return cover_media_file;
}
public void setCover_media_file(String cover_media_file) {
this.cover_media_file = cover_media_file;
}
public String getStart_video() {
return start_video;
}
public void setStart_video(String start_video) {
this.start_video = start_video;
}
public String getCopyright() {
return copyright;
}
public void setCopyright(String copyright) {
this.copyright = copyright;
}
public AnswererBean getAnswerer() {
return answerer;
}
public void setAnswerer(AnswererBean answerer) {
this.answerer = answerer;
}
public AskerBean getAsker() {
return asker;
}
public void setAsker(AskerBean asker) {
this.asker = asker;
}
public String getNext_id() {
return next_id;
}
public void setNext_id(String next_id) {
this.next_id = next_id;
}
public String getPrevious_id() {
return previous_id;
}
public void setPrevious_id(String previous_id) {
this.previous_id = previous_id;
}
public ShareListBean getShare_list() {
return share_list;
}
public void setShare_list(ShareListBean share_list) {
this.share_list = share_list;
}
public int getPraisenum() {
return praisenum;
}
public void setPraisenum(int praisenum) {
this.praisenum = praisenum;
}
public int getSharenum() {
return sharenum;
}
public void setSharenum(int sharenum) {
this.sharenum = sharenum;
}
public int getCommentnum() {
return commentnum;
}
public void setCommentnum(int commentnum) {
this.commentnum = commentnum;
}
public List<AuthorListBean> getAuthor_list() {
return author_list;
}
public void setAuthor_list(List<AuthorListBean> author_list) {
this.author_list = author_list;
}
public List<AskerListBean> getAsker_list() {
return asker_list;
}
public void setAsker_list(List<AskerListBean> asker_list) {
this.asker_list = asker_list;
}
public List<?> getTag_list() {
return tag_list;
}
public void setTag_list(List<?> tag_list) {
this.tag_list = tag_list;
}
public static class AnswererBean {
/**
* user_id : 7566818
* user_name : 温义飞
* desc : 有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。
* wb_name : @Blake老实人
* is_settled : 0
* settled_type : 0
* summary : 温义飞，ONE热门回答者。
* fans_total : 353
* web_url : http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1
*/
private String user_id;
private String user_name;
private String desc;
private String wb_name;
private String is_settled;
private String settled_type;
private String summary;
private String fans_total;
private String web_url;
public String getUser_id() {
return user_id;
}
public void setUser_id(String user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getWb_name() {
return wb_name;
}
public void setWb_name(String wb_name) {
this.wb_name = wb_name;
}
public String getIs_settled() {
return is_settled;
}
public void setIs_settled(String is_settled) {
this.is_settled = is_settled;
}
public String getSettled_type() {
return settled_type;
}
public void setSettled_type(String settled_type) {
this.settled_type = settled_type;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getFans_total() {
return fans_total;
}
public void setFans_total(String fans_total) {
this.fans_total = fans_total;
}
public String getWeb_url() {
return web_url;
}
public void setWeb_url(String web_url) {
this.web_url = web_url;
}
}
public static class AskerBean {
/**
* user_id : 0
* user_name : lilizhou
* web_url : http://image.wufazhuce.com/placeholder-author-avatar.png
* summary :
* desc :
* is_settled :
* settled_type :
* fans_total :
* wb_name :
*/
private String user_id;
private String user_name;
private String web_url;
private String summary;
private String desc;
private String is_settled;
private String settled_type;
private String fans_total;
private String wb_name;
public String getUser_id() {
return user_id;
}
public void setUser_id(String user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getWeb_url() {
return web_url;
}
public void setWeb_url(String web_url) {
this.web_url = web_url;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getIs_settled() {
return is_settled;
}
public void setIs_settled(String is_settled) {
this.is_settled = is_settled;
}
public String getSettled_type() {
return settled_type;
}
public void setSettled_type(String settled_type) {
this.settled_type = settled_type;
}
public String getFans_total() {
return fans_total;
}
public void setFans_total(String fans_total) {
this.fans_total = fans_total;
}
public String getWb_name() {
return wb_name;
}
public void setWb_name(String wb_name) {
this.wb_name = wb_name;
}
}
public static class ShareListBean {
/**
* wx : {"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=singlemessage","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""}
* wx_timeline : {"title":"问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=timeline","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""}
* weibo : {"title":"ONE一个《问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？》 文/温义飞： 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。 阅读全文：http://m.wufazhuce.com/question/1593?channel=weibo 下载ONE一个APP:http://weibo.com/p/100404157874","desc":"","link":"http://m.wufazhuce.com/question/1593?channel=weibo","imgUrl":"","audio":""}
* qq : {"title":"美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？","desc":"这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。","link":"http://m.wufazhuce.com/question/1593?channel=qq","imgUrl":"http://image.wufazhuce.com/ONE_logo_120_square.png","audio":""}
*/
private WxBean wx;
private WxTimelineBean wx_timeline;
private WeiboBean weibo;
private QqBean qq;
public WxBean getWx() {
return wx;
}
public void setWx(WxBean wx) {
this.wx = wx;
}
public WxTimelineBean getWx_timeline() {
return wx_timeline;
}
public void setWx_timeline(WxTimelineBean wx_timeline) {
this.wx_timeline = wx_timeline;
}
public WeiboBean getWeibo() {
return weibo;
}
public void setWeibo(WeiboBean weibo) {
this.weibo = weibo;
}
public QqBean getQq() {
return qq;
}
public void setQq(QqBean qq) {
this.qq = qq;
}
public static class WxBean {
/**
* title : 问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？
* desc : 文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。
* link : http://m.wufazhuce.com/question/1593?channel=singlemessage
* imgUrl : http://image.wufazhuce.com/ONE_logo_120_square.png
* audio :
*/
private String title;
private String desc;
private String link;
private String imgUrl;
private String audio;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}
public String getAudio() {
return audio;
}
public void setAudio(String audio) {
this.audio = audio;
}
}
public static class WxTimelineBean {
/**
* title : 问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？
* desc : 文/温义飞 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。
* link : http://m.wufazhuce.com/question/1593?channel=timeline
* imgUrl : http://image.wufazhuce.com/ONE_logo_120_square.png
* audio :
*/
private String title;
private String desc;
private String link;
private String imgUrl;
private String audio;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}
public String getAudio() {
return audio;
}
public void setAudio(String audio) {
this.audio = audio;
}
}
public static class WeiboBean {
/**
* title : ONE一个《问答 | 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？》 文/温义飞： 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。 阅读全文：http://m.wufazhuce.com/question/1593?channel=weibo 下载ONE一个APP:http://weibo.com/p/100404157874
* desc :
* link : http://m.wufazhuce.com/question/1593?channel=weibo
* imgUrl :
* audio :
*/
private String title;
private String desc;
private String link;
private String imgUrl;
private String audio;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}
public String getAudio() {
return audio;
}
public void setAudio(String audio) {
this.audio = audio;
}
}
public static class QqBean {
/**
* title : 美国队长的盾是钢铁侠的爸爸送的，那么钢铁侠有权利要回来吗？
* desc : 这个盾反复殴打赠与人的亲儿子钢铁侠，深深地伤害了妮妮的肉体和感情。
* link : http://m.wufazhuce.com/question/1593?channel=qq
* imgUrl : http://image.wufazhuce.com/ONE_logo_120_square.png
* audio :
*/
private String title;
private String desc;
private String link;
private String imgUrl;
private String audio;
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
public String getImgUrl() {
return imgUrl;
}
public void setImgUrl(String imgUrl) {
this.imgUrl = imgUrl;
}
public String getAudio() {
return audio;
}
public void setAudio(String audio) {
this.audio = audio;
}
}
}
public static class AuthorListBean {
/**
* user_id : 7566818
* user_name : 温义飞
* desc : 有时也会迷惑，人们爱的究竟是我的美貌还是我的才华。
* wb_name : @Blake老实人
* is_settled : 0
* settled_type : 0
* summary : 温义飞，ONE热门回答者。
* fans_total : 353
* web_url : http://image.wufazhuce.com/FjN55lHN2vK5VgA5c1c8opFeUrG1
*/
private String user_id;
private String user_name;
private String desc;
private String wb_name;
private String is_settled;
private String settled_type;
private String summary;
private String fans_total;
private String web_url;
public String getUser_id() {
return user_id;
}
public void setUser_id(String user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getWb_name() {
return wb_name;
}
public void setWb_name(String wb_name) {
this.wb_name = wb_name;
}
public String getIs_settled() {
return is_settled;
}
public void setIs_settled(String is_settled) {
this.is_settled = is_settled;
}
public String getSettled_type() {
return settled_type;
}
public void setSettled_type(String settled_type) {
this.settled_type = settled_type;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getFans_total() {
return fans_total;
}
public void setFans_total(String fans_total) {
this.fans_total = fans_total;
}
public String getWeb_url() {
return web_url;
}
public void setWeb_url(String web_url) {
this.web_url = web_url;
}
}
public static class AskerListBean {
/**
* user_id : 0
* user_name : lilizhou
* web_url : http://image.wufazhuce.com/placeholder-author-avatar.png
* summary :
* desc :
* is_settled :
* settled_type :
* fans_total :
* wb_name :
*/
private String user_id;
private String user_name;
private String web_url;
private String summary;
private String desc;
private String is_settled;
private String settled_type;
private String fans_total;
private String wb_name;
public String getUser_id() {
return user_id;
}
public void setUser_id(String user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getWeb_url() {
return web_url;
}
public void setWeb_url(String web_url) {
this.web_url = web_url;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getIs_settled() {
return is_settled;
}
public void setIs_settled(String is_settled) {
this.is_settled = is_settled;
}
public String getSettled_type() {
return settled_type;
}
public void setSettled_type(String settled_type) {
this.settled_type = settled_type;
}
public String getFans_total() {
return fans_total;
}
public void setFans_total(String fans_total) {
this.fans_total = fans_total;
}
public String getWb_name() {
return wb_name;
}
public void setWb_name(String wb_name) {
this.wb_name = wb_name;
}
}
}
}
| [
"[email protected]"
] | |
9013e722da43c1dac6e53876d48a63dd56c903b1 | 2650d565255cf7f5c0192599cb69650aba91fdb8 | /java/src/main/java/com/ciaoshen/leetcode/MaxAreaOfIsland.java | 67cfb443d89c115dfd19351b6038aac15322a187 | [
"MIT"
] | permissive | helloShen/leetcode | 78ded31b16cfc0ca4d0618d90bb0ef3a8b10377a | 5bba26f0612d785800c990947db8dae3af4bad81 | refs/heads/master | 2021-06-03T14:44:57.256143 | 2019-04-06T19:06:15 | 2019-04-06T19:06:15 | 96,709,063 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,950 | java | /**
* Leetcode - Algorithm - MaxAreaOfIsland
*/
package com.ciaoshen.leetcode;
import java.util.*;
import com.ciaoshen.leetcode.myUtils.*;
/**
* Each problem is initialized with 3 solutions.
* You can expand more solutions.
* Before using your new solutions, don't forget to register them to the solution registry.
*/
class MaxAreaOfIsland implements Problem {
private Map<Integer,Solution> solutions = new HashMap<>(); // solutions registry
// register solutions HERE...
private MaxAreaOfIsland() {
register(new Solution1());
register(new Solution2());
register(new Solution3());
}
private abstract class Solution {
private int id = 0;
abstract public int maxAreaOfIsland(int[][] grid); // 主方法接口
protected void sometest() { return; } // 预留的一些小测试的接口
}
private class Solution1 extends Solution {
{ super.id = 1; }
private int[] count = new int[0];
private int[] board = new int[0];
private void init(int[][] grid) {
int height = grid.length;
int width = grid[0].length;
count = new int[height * width + 1];
board = new int[height * width + 1];
}
public int maxAreaOfIsland(int[][] grid) {
int height = grid.length;
if (height == 0) { return 0; }
int width = grid[0].length;
init(grid);
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
if (grid[i][j] == 1) {
int posCurr = j+1 + width * i, posLeft = -1, posUpper = -1;
create(posCurr);
if (j > 0 && grid[i][j-1] == 1) {
posLeft = j + width * i;
merge(posCurr,posLeft); // 当前树嫁接到左树
}
if (i > 0 && grid[i-1][j] == 1) {
posUpper = j+1 + width * (i-1);
merge(posCurr,posUpper); // 当前树嫁接到上树
}
}
}
}
int max = 0;
for (int i = 0; i < count.length; i++) {
max = Math.max(max,count[i]);
}
// System.out.println(Arrays.toString(count));
// System.out.println(Arrays.toString(board));
return max;
}
private void create(int pos) {
board[pos] = pos;
count[pos] = 1;
}
private int find(int pos) {
if (board[pos] == pos) {
return pos;
} else {
int root = find(board[pos]);
board[pos] = root; // path compression
return root;
}
}
// root1嫁接到root2上
private void merge(int pos1, int pos2) {
int root1 = find(pos1);
int root2 = find(pos2);
if (root1 != root2) {
board[root1] = board[root2];
// System.out.println("Merge Group " + root1 + " to Group " + root2);
// System.out.println(count[root1] + " members from Group " + root1 + " merged to Group " + root2 + " with " + count[root2] + " members.");
count[root2] += count[root1];
count[root1] = 0;
}
}
}
private class Solution2 extends Solution {
{ super.id = 2; }
public int maxAreaOfIsland(int[][] grid) {
return 2;
}
}
private class Solution3 extends Solution {
{ super.id = 3; }
public int maxAreaOfIsland(int[][] grid) {
return 3;
}
}
// you can expand more solutions HERE if you want...
/**
* register a solution in the solution registry
* return false if this type of solution already exist in the registry.
*/
private boolean register(Solution s) {
return (solutions.put(s.id,s) == null)? true : false;
}
/**
* chose one of the solution to test
* return null if solution id does not exist
*/
private Solution solution(int id) {
return solutions.get(id);
}
private static class Test {
private MaxAreaOfIsland problem = new MaxAreaOfIsland();
private Solution solution = null;
// call method in solution
private void call(int[][] grid, int ans) {
Matrix.print(grid);
System.out.println("Max Area = " + solution.maxAreaOfIsland(grid) + "\t [Answer: " + ans + "]\n");
}
// public API of Test interface
public void test(int id) {
solution = problem.solution(id);
if (solution == null) { System.out.println("Sorry, [id:" + id + "] doesn't exist!"); return; }
System.out.println("\nCall Solution" + solution.id);
/** initialize your testcases HERE... */
int[][] grid1 = new int[][]{
{0,0,1,0,0,0,0,1,0,0,0,0,0},
{0,0,0,0,0,0,0,1,1,1,0,0,0},
{0,1,1,0,1,0,0,0,0,0,0,0,0},
{0,1,0,0,1,1,0,0,1,0,1,0,0},
{0,1,0,0,1,1,0,0,1,1,1,0,0},
{0,0,0,0,0,0,0,0,0,0,1,0,0},
{0,0,0,0,0,0,0,1,1,1,0,0,0},
{0,0,0,0,0,0,0,1,1,0,0,0,0}
};
int ans1 = 6;
int[][] grid2 = new int[][] {
{1,1,0,0,0},
{1,1,0,0,0},
{0,0,0,1,1},
{0,0,0,1,1}
};
int ans2 = 4;
/** involk call() method HERE */
call(grid1,ans1);
call(grid2,ans2);
}
}
public static void main(String[] args) {
Test test = new Test();
test.test(1);
// test.test(2);
// test.test(3);
}
}
| [
"[email protected]"
] | |
f2290ca35cdf55ddcd27ff1e25d8d11e9762578f | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/1/1_701e99900d9312579f7e835163563db4dacc5f40/BsonJackson/1_701e99900d9312579f7e835163563db4dacc5f40_BsonJackson_s.java | 9645b1f38cb5adecc1ae3a8347087bacae0c7ec5 | [] | no_license | zhongxingyu/Seer | 48e7e5197624d7afa94d23f849f8ea2075bcaec0 | c11a3109fdfca9be337e509ecb2c085b60076213 | refs/heads/master | 2023-07-06T12:48:55.516692 | 2023-06-22T07:55:56 | 2023-06-22T07:55:56 | 259,613,157 | 6 | 2 | null | 2023-06-22T07:55:57 | 2020-04-28T11:07:49 | null | UTF-8 | Java | false | false | 384 | java | package serializers;
import de.undercouch.bson4jackson.BsonFactory;
import de.undercouch.bson4jackson.BsonGenerator;
public class BsonJackson
{
public static void register(TestGroups groups)
{
BsonFactory factory = new BsonFactory();
groups.media.add(JavaBuiltIn.MediaTransformer,
new JsonJacksonManual.GenericSerializer("bson/jackson-manual", factory));
}
}
| [
"[email protected]"
] | |
bdabfcf35ba10a8c8385021c4fe6bbbc5ce25c52 | a5c2f06bd10237c9b43098453967012f3836acd9 | /src/main/java/tries/ValidWordsFromDictionary.java | ce9336c7b7148f319b3eb151e6a92cb11962602d | [] | no_license | swapnilbagadia/practice | bd33a158fe6267a96692ca267a83fc1981cf47a4 | 63b7999905081ae5202979eafde5d35224929612 | refs/heads/master | 2020-04-12T22:38:36.898976 | 2019-01-07T04:50:53 | 2019-01-07T04:50:53 | 162,793,912 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,257 | java | package main.java.tries;
public class ValidWordsFromDictionary {
static final int SIZE = 26;
static class TrieNode{
boolean leaf;
TrieNode[] Child = new TrieNode[SIZE];
// Constructor
public TrieNode() {
leaf = false;
for (int i =0 ; i< SIZE ; i++)
Child[i] = null;
}
}
// If not present, inserts key into trie
// If the key is prefix of trie node, just
// marks leaf node
static void insert(TrieNode root, String Key)
{
int n = Key.length();
TrieNode pChild = root;
for (int i=0; i<n; i++)
{
int index = Key.charAt(i) - 'a';
if (pChild.Child[index] == null)
pChild.Child[index] = new TrieNode();
pChild = pChild.Child[index];
}
// make last node as leaf node
pChild.leaf = true;
}
// A recursive function to print all possible valid
// words present in array
static void searchWord(TrieNode root, boolean Hash[],
String str)
{
// if we found word in trie / dictionary
if (root.leaf == true)
System.out.println(str);
// traverse all child's of current root
for (int K =0; K < SIZE; K++)
{
if (Hash[K] == true && root.Child[K] != null )
{
// add current character
char c = (char) (K + 'a');
// Recursively search reaming character
// of word in trie
searchWord(root.Child[K], Hash, str + c);
}
}
}
// Prints all words present in dictionary.
static void printAllWords(char Arr[], TrieNode root,
int n)
{
// create a 'has' array that will store all
// present character in Arr[]
boolean[] Hash = new boolean[SIZE];
for (int i = 0 ; i < n; i++)
Hash[Arr[i] - 'a'] = true;
// tempary node
TrieNode pChild = root ;
// string to hold output words
String str = "";
// Traverse all matrix elements. There are only
// 26 character possible in char array
for (int i = 0 ; i < SIZE ; i++)
{
// we start searching for word in dictionary
// if we found a character which is child
// of Trie root
if (Hash[i] == true && pChild.Child[i] != null )
{
str = str+(char)(i + 'a');
searchWord(pChild.Child[i], Hash, str);
str = "";
}
}
}
//Driver program to test above function
public static void main(String args[])
{
// Let the given dictionary be following
String Dict[] = {"go", "bat", "me", "eat",
"goal", "boy", "run"} ;
// Root Node of Trie
TrieNode root = new TrieNode();
// insert all words of dictionary into trie
int n = Dict.length;
for (int i=0; i<n; i++)
insert(root, Dict[i]);
char arr[] = {'e', 'o', 'b', 'a', 'm', 'g', 'l', 't'} ;
int N = arr.length;
printAllWords(arr, root, N);
}
}
| [
"[email protected]"
] | |
d53486c4e40354b6975e7e33eba6db823577877b | c188408c9ec0425666250b45734f8b4c9644a946 | /open-sphere-base/core/src/main/java/net/opengis/gml/_311/TemporalDatumRefType.java | 8a6f428ce3eb9b3e476e762bb83a8a3924e4086a | [
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | rkausch/opensphere-desktop | ef8067eb03197c758e3af40ebe49e182a450cc02 | c871c4364b3456685411fddd22414fd40ce65699 | refs/heads/snapshot_5.2.7 | 2023-04-13T21:00:00.575303 | 2020-07-29T17:56:10 | 2020-07-29T17:56:10 | 360,594,280 | 0 | 0 | Apache-2.0 | 2021-04-22T17:40:38 | 2021-04-22T16:58:41 | null | UTF-8 | Java | false | false | 6,882 | java | //
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vhudson-jaxb-ri-2.2-147
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2010.01.26 at 02:04:22 PM MST
//
package net.opengis.gml._311;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
/**
* Association to a temporal datum, either referencing or containing the definition of that datum.
*
* <p>Java class for TemporalDatumRefType complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType name="TemporalDatumRefType">
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence minOccurs="0">
* <element ref="{http://www.opengis.net/gml}TemporalDatum"/>
* </sequence>
* <attGroup ref="{http://www.opengis.net/gml}AssociationAttributeGroup"/>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TemporalDatumRefType", propOrder = {
"temporalDatum"
})
public class TemporalDatumRefType {
@XmlElement(name = "TemporalDatum")
protected TemporalDatumType temporalDatum;
@XmlAttribute(name = "remoteSchema", namespace = "http://www.opengis.net/gml")
@XmlSchemaType(name = "anyURI")
protected String remoteSchema;
@XmlAttribute(name = "type", namespace = "http://www.w3.org/1999/xlink")
protected String type;
@XmlAttribute(name = "href", namespace = "http://www.w3.org/1999/xlink")
@XmlSchemaType(name = "anyURI")
protected String href;
@XmlAttribute(name = "role", namespace = "http://www.w3.org/1999/xlink")
@XmlSchemaType(name = "anyURI")
protected String role;
@XmlAttribute(name = "arcrole", namespace = "http://www.w3.org/1999/xlink")
@XmlSchemaType(name = "anyURI")
protected String arcrole;
@XmlAttribute(name = "title", namespace = "http://www.w3.org/1999/xlink")
protected String title;
@XmlAttribute(name = "show", namespace = "http://www.w3.org/1999/xlink")
protected String show;
@XmlAttribute(name = "actuate", namespace = "http://www.w3.org/1999/xlink")
protected String actuate;
/**
* Gets the value of the temporalDatum property.
*
* @return
* possible object is
* {@link TemporalDatumType }
*
*/
public TemporalDatumType getTemporalDatum() {
return temporalDatum;
}
/**
* Sets the value of the temporalDatum property.
*
* @param value
* allowed object is
* {@link TemporalDatumType }
*
*/
public void setTemporalDatum(TemporalDatumType value) {
this.temporalDatum = value;
}
/**
* Gets the value of the remoteSchema property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getRemoteSchema() {
return remoteSchema;
}
/**
* Sets the value of the remoteSchema property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setRemoteSchema(String value) {
this.remoteSchema = value;
}
/**
* Gets the value of the type property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getType() {
if (type == null) {
return "simple";
} else {
return type;
}
}
/**
* Sets the value of the type property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setType(String value) {
this.type = value;
}
/**
* Gets the value of the href property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getHref() {
return href;
}
/**
* Sets the value of the href property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setHref(String value) {
this.href = value;
}
/**
* Gets the value of the role property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getRole() {
return role;
}
/**
* Sets the value of the role property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setRole(String value) {
this.role = value;
}
/**
* Gets the value of the arcrole property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getArcrole() {
return arcrole;
}
/**
* Sets the value of the arcrole property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setArcrole(String value) {
this.arcrole = value;
}
/**
* Gets the value of the title property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getTitle() {
return title;
}
/**
* Sets the value of the title property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setTitle(String value) {
this.title = value;
}
/**
* Gets the value of the show property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getShow() {
return show;
}
/**
* Sets the value of the show property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setShow(String value) {
this.show = value;
}
/**
* Gets the value of the actuate property.
*
* @return
* possible object is
* {@link String }
*
*/
public String getActuate() {
return actuate;
}
/**
* Sets the value of the actuate property.
*
* @param value
* allowed object is
* {@link String }
*
*/
public void setActuate(String value) {
this.actuate = value;
}
}
| [
"[email protected]"
] | |
ddfcaa635b1571517e065a13cc9c0ca800d7fa07 | 5291a176fd6fbed1791308af8e0dcbd1d802b7e1 | /Board.java | c4a19491faa3ae869f87d7ecb0f8c30ff12892af | [] | no_license | OliveIsLazy/Amazons2018 | 992450aa1f2d1e215a7536bf72b74bd369a6cf5a | daf84282465c6e9327864c7d61a5c240d857ee80 | refs/heads/master | 2020-04-13T14:53:33.649133 | 2018-12-24T12:03:00 | 2018-12-24T12:03:00 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,632 | java | import java.awt.Color;
import javafx.scene.layout.Border;
public class Board {
public GameTile[][] tiles;
public int size;
public boolean enabled = true;
private Game parentGame;
/*
* input: number of columns, number of rows Builds a args[2] x args[3] size
* chess board using GameTiles return: void
*/
Board(Integer width, Integer height, Game game) {
parentGame = game;
size = width.intValue();
this.tiles = new GameTile[width.intValue()][height.intValue()];
for (int ii = 0; ii < this.tiles.length; ii++) {
for (int jj = 0; jj < this.tiles[ii].length; jj++) {
if ((jj % 2 == 1 && ii % 2 == 1) || (jj % 2 == 0 && ii % 2 == 0))
this.tiles[jj][ii] = new GameTile(Color.WHITE, jj, ii, game);
else
this.tiles[jj][ii] = new GameTile(Color.BLACK, jj, ii, game);
}
}
}
public String encode() {
String board = "";
for (GameTile[] row : tiles) {
for (GameTile tile : row) {
if (tile.wasShot)
board += "a";
else if (tile.hasPiece)
board += (tile.piece.color == Color.black) ? "b" : "w";
else
board += "e";
}
}
return board;
}
public boolean decode(String board) {
try {
assert (board.length() == tiles.length * tiles[0].length);
int index, black_index, white_index;
index = black_index = white_index = 0;
GameTile[][] newTiles = tiles.clone();
for (GameTile[] row : newTiles) {
for (GameTile tile : row) {
switch (board.charAt(index)) {
case 'a':
tile.shoot();
break;
case 'b':
tile.setPiece(this.parentGame.getPlayer("Black").pawns.get(black_index));
black_index++;
break;
case 'w':
tile.setPiece(this.parentGame.getPlayer("White").pawns.get(white_index));
white_index++;
break;
case 'e':
tile.empty();
}
index++;
}
}
assert (black_index == 4 && white_index == 4);
tiles = newTiles;
this.parentGame.findAllPaths();
return true;
} catch (AssertionError e) {
return false;
}
}
/*
* input: void Resets board to not show any paths return: void
*/
public void clear() {
for (GameTile[] row : tiles)
for (GameTile tile : row)
tile.setToDefaultColor();
}
public void empty() {
for (GameTile[] row : tiles)
for (GameTile tile : row)
tile.empty();
}
public void assertEmptiness() {
for (GameTile[] row : tiles)
for (GameTile tile : row)
assert (tile.hasPiece == false);
}
public void disable() {
// disable the whole board
enabled = false;
for (GameTile[] row : tiles)
for (GameTile tile : row)
tile.setEnabled(false);
}
public void enable() {
enabled = true;
// disable the whole board
for (GameTile[] row : tiles)
for (GameTile tile : row)
tile.setEnabled(true);
}
} | [
"[email protected]"
] | |
2159ee7fcb953bc7bbd6151887432ce26c14b55f | ebc4297fae19303a1fde2d649eb8387ecbca2f1b | /HomeWorks/Homework_5/Program.java | c40afcd2cc296a7054a01776f1fcef13c1c77302 | [] | no_license | HaKooNa-MaTaTa/IGONIN_JAVA_120 | e2be8247450933d407dbfccb69c117498da2aa1d | dbb677ebd155214e85e1f31f1658f5cd1e106eb3 | refs/heads/master | 2020-05-15T06:22:13.515337 | 2019-10-08T19:34:24 | 2019-10-08T19:34:24 | 182,122,905 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 977 | java | import java.util.Scanner;
class Program {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Please, enter size array");
int sizeArray = scanner.nextInt();
int array[] = new int[sizeArray];
int numbers = 0;
int maxDigits = 0;
int minDigits = 0;
int i = 0;
while ( i < sizeArray) {
numbers = scanner.nextInt();
array[i] = numbers;
i++;
}
System.out.print("Amount local maximum: ");
for (i = 0; i <= sizeArray-2; i++) {
if ( i != 0) {
if (array[i-1] < array[i]) {
if(array[i] > array[i+1]) {
maxDigits = maxDigits + 1;
}
}
}
}
System.out.println(maxDigits);
System.out.print("Amount local minimum: ");
for (i = 0; i <= sizeArray-2; i++) {
if ( i != 0) {
if (array[i-1] > array[i]) {
if (array[i] < array[i+1]) {
minDigits = minDigits + 1;
}
}
}
}
System.out.println(minDigits);
}
} | [
"[email protected]"
] | |
23b331552021ebb50e074fb52746451c00bd1833 | 83ba1ffe094176c7c6036a9ea47751b031941fc4 | /runners/google-cloud-dataflow-java/src/test/java/com/google/cloud/dataflow/sdk/runners/DataflowPipelineJobTest.java | 764c0cba7f8a57b72e13c5ffb550c096cbca9dfa | [
"Apache-2.0"
] | permissive | Sil1991/gcpdf-demo | b7b57f476bb5bce5e80e4c160512a52937036241 | 88ecd538a30f009b239a1b320ab6ad75f6901ae0 | refs/heads/master | 2022-11-24T23:36:03.156413 | 2018-04-10T15:29:49 | 2018-04-10T15:29:49 | 128,814,619 | 1 | 0 | Apache-2.0 | 2022-11-16T08:29:25 | 2018-04-09T18:13:21 | Java | UTF-8 | Java | false | false | 25,421 | java | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.cloud.dataflow.sdk.runners;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.hasEntry;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import com.google.api.services.dataflow.Dataflow;
import com.google.api.services.dataflow.Dataflow.Projects.Jobs.Get;
import com.google.api.services.dataflow.Dataflow.Projects.Jobs.GetMetrics;
import com.google.api.services.dataflow.Dataflow.Projects.Jobs.Messages;
import com.google.api.services.dataflow.model.Job;
import com.google.api.services.dataflow.model.JobMetrics;
import com.google.api.services.dataflow.model.MetricStructuredName;
import com.google.api.services.dataflow.model.MetricUpdate;
import com.google.cloud.dataflow.sdk.PipelineResult.State;
import com.google.cloud.dataflow.sdk.runners.dataflow.DataflowAggregatorTransforms;
import com.google.cloud.dataflow.sdk.testing.FastNanoClockAndSleeper;
import com.google.cloud.dataflow.sdk.transforms.Aggregator;
import com.google.cloud.dataflow.sdk.transforms.AppliedPTransform;
import com.google.cloud.dataflow.sdk.transforms.Combine.CombineFn;
import com.google.cloud.dataflow.sdk.transforms.PTransform;
import com.google.cloud.dataflow.sdk.transforms.Sum;
import com.google.cloud.dataflow.sdk.util.AttemptBoundedExponentialBackOff;
import com.google.cloud.dataflow.sdk.util.MonitoringUtil;
import com.google.cloud.dataflow.sdk.values.PInput;
import com.google.cloud.dataflow.sdk.values.POutput;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSetMultimap;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.SocketTimeoutException;
import java.util.concurrent.TimeUnit;
/**
* Tests for DataflowPipelineJob.
*/
@RunWith(JUnit4.class)
public class DataflowPipelineJobTest {
private static final String PROJECT_ID = "someProject";
private static final String JOB_ID = "1234";
@Mock
private Dataflow mockWorkflowClient;
@Mock
private Dataflow.Projects mockProjects;
@Mock
private Dataflow.Projects.Jobs mockJobs;
@Rule
public FastNanoClockAndSleeper fastClock = new FastNanoClockAndSleeper();
@Rule
public ExpectedException thrown = ExpectedException.none();
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
when(mockWorkflowClient.projects()).thenReturn(mockProjects);
when(mockProjects.jobs()).thenReturn(mockJobs);
}
/**
* Validates that a given time is valid for the total time slept by a
* AttemptBoundedExponentialBackOff given the number of retries and
* an initial polling interval.
*
* @param pollingIntervalMillis The initial polling interval given.
* @param attempts The number of attempts made
* @param timeSleptMillis The amount of time slept by the clock. This is checked
* against the valid interval.
*/
void checkValidInterval(long pollingIntervalMillis, int attempts, long timeSleptMillis) {
long highSum = 0;
long lowSum = 0;
for (int i = 1; i < attempts; i++) {
double currentInterval =
pollingIntervalMillis
* Math.pow(AttemptBoundedExponentialBackOff.DEFAULT_MULTIPLIER, i - 1);
double offset =
AttemptBoundedExponentialBackOff.DEFAULT_RANDOMIZATION_FACTOR * currentInterval;
highSum += Math.round(currentInterval + offset);
lowSum += Math.round(currentInterval - offset);
}
assertThat(timeSleptMillis, allOf(greaterThanOrEqualTo(lowSum), lessThanOrEqualTo(highSum)));
}
@Test
public void testWaitToFinishMessagesFail() throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
Job statusResponse = new Job();
statusResponse.setCurrentState("JOB_STATE_" + State.DONE.name());
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenReturn(statusResponse);
MonitoringUtil.JobMessagesHandler jobHandler = mock(MonitoringUtil.JobMessagesHandler.class);
Dataflow.Projects.Jobs.Messages mockMessages =
mock(Dataflow.Projects.Jobs.Messages.class);
Messages.List listRequest = mock(Dataflow.Projects.Jobs.Messages.List.class);
when(mockJobs.messages()).thenReturn(mockMessages);
when(mockMessages.list(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(listRequest);
when(listRequest.execute()).thenThrow(SocketTimeoutException.class);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
State state = job.waitToFinish(5, TimeUnit.MINUTES, jobHandler, fastClock, fastClock);
assertEquals(null, state);
}
public State mockWaitToFinishInState(State state) throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
Job statusResponse = new Job();
statusResponse.setCurrentState("JOB_STATE_" + state.name());
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenReturn(statusResponse);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
return job.waitToFinish(1, TimeUnit.MINUTES, null, fastClock, fastClock);
}
/**
* Tests that the {@link DataflowPipelineJob} understands that the {@link State#DONE DONE}
* state is terminal.
*/
@Test
public void testWaitToFinishDone() throws Exception {
assertEquals(State.DONE, mockWaitToFinishInState(State.DONE));
}
/**
* Tests that the {@link DataflowPipelineJob} understands that the {@link State#FAILED FAILED}
* state is terminal.
*/
@Test
public void testWaitToFinishFailed() throws Exception {
assertEquals(State.FAILED, mockWaitToFinishInState(State.FAILED));
}
/**
* Tests that the {@link DataflowPipelineJob} understands that the {@link State#FAILED FAILED}
* state is terminal.
*/
@Test
public void testWaitToFinishCancelled() throws Exception {
assertEquals(State.CANCELLED, mockWaitToFinishInState(State.CANCELLED));
}
/**
* Tests that the {@link DataflowPipelineJob} understands that the {@link State#FAILED FAILED}
* state is terminal.
*/
@Test
public void testWaitToFinishUpdated() throws Exception {
assertEquals(State.UPDATED, mockWaitToFinishInState(State.UPDATED));
}
@Test
public void testWaitToFinishFail() throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenThrow(IOException.class);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
long startTime = fastClock.nanoTime();
State state = job.waitToFinish(5, TimeUnit.MINUTES, null, fastClock, fastClock);
assertEquals(null, state);
long timeDiff = TimeUnit.NANOSECONDS.toMillis(fastClock.nanoTime() - startTime);
checkValidInterval(DataflowPipelineJob.MESSAGES_POLLING_INTERVAL,
DataflowPipelineJob.MESSAGES_POLLING_ATTEMPTS, timeDiff);
}
@Test
public void testWaitToFinishTimeFail() throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenThrow(IOException.class);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
long startTime = fastClock.nanoTime();
State state = job.waitToFinish(4, TimeUnit.MILLISECONDS, null, fastClock, fastClock);
assertEquals(null, state);
long timeDiff = TimeUnit.NANOSECONDS.toMillis(fastClock.nanoTime() - startTime);
// Should only sleep for the 4 ms remaining.
assertEquals(timeDiff, 4L);
}
@Test
public void testGetStateReturnsServiceState() throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
Job statusResponse = new Job();
statusResponse.setCurrentState("JOB_STATE_" + State.RUNNING.name());
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenReturn(statusResponse);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
assertEquals(
State.RUNNING,
job.getStateWithRetries(DataflowPipelineJob.STATUS_POLLING_ATTEMPTS, fastClock));
}
@Test
public void testGetStateWithExceptionReturnsUnknown() throws Exception {
Dataflow.Projects.Jobs.Get statusRequest = mock(Dataflow.Projects.Jobs.Get.class);
when(mockJobs.get(eq(PROJECT_ID), eq(JOB_ID))).thenReturn(statusRequest);
when(statusRequest.execute()).thenThrow(IOException.class);
DataflowAggregatorTransforms dataflowAggregatorTransforms =
mock(DataflowAggregatorTransforms.class);
DataflowPipelineJob job = new DataflowPipelineJob(
PROJECT_ID, JOB_ID, mockWorkflowClient, dataflowAggregatorTransforms);
long startTime = fastClock.nanoTime();
assertEquals(
State.UNKNOWN,
job.getStateWithRetries(DataflowPipelineJob.STATUS_POLLING_ATTEMPTS, fastClock));
long timeDiff = TimeUnit.NANOSECONDS.toMillis(fastClock.nanoTime() - startTime);
checkValidInterval(DataflowPipelineJob.STATUS_POLLING_INTERVAL,
DataflowPipelineJob.STATUS_POLLING_ATTEMPTS, timeDiff);
}
@Test
public void testGetAggregatorValuesWithNoMetricUpdatesReturnsEmptyValue()
throws IOException, AggregatorRetrievalException {
Aggregator<?, ?> aggregator = mock(Aggregator.class);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(aggregator, pTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(appliedTransform, stepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
JobMetrics jobMetrics = new JobMetrics();
when(getMetrics.execute()).thenReturn(jobMetrics);
jobMetrics.setMetrics(ImmutableList.<MetricUpdate>of());
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
AggregatorValues<?> values = job.getAggregatorValues(aggregator);
assertThat(values.getValues(), empty());
}
@Test
public void testGetAggregatorValuesWithNullMetricUpdatesReturnsEmptyValue()
throws IOException, AggregatorRetrievalException {
Aggregator<?, ?> aggregator = mock(Aggregator.class);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(aggregator, pTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(appliedTransform, stepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
JobMetrics jobMetrics = new JobMetrics();
when(getMetrics.execute()).thenReturn(jobMetrics);
jobMetrics.setMetrics(null);
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
AggregatorValues<?> values = job.getAggregatorValues(aggregator);
assertThat(values.getValues(), empty());
}
@Test
public void testGetAggregatorValuesWithSingleMetricUpdateReturnsSingletonCollection()
throws IOException, AggregatorRetrievalException {
CombineFn<Long, long[], Long> combineFn = new Sum.SumLongFn();
String aggregatorName = "agg";
Aggregator<Long, Long> aggregator = new TestAggregator<>(combineFn, aggregatorName);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(aggregator, pTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(appliedTransform, stepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
JobMetrics jobMetrics = new JobMetrics();
when(getMetrics.execute()).thenReturn(jobMetrics);
MetricUpdate update = new MetricUpdate();
long stepValue = 1234L;
update.setScalar(new BigDecimal(stepValue));
MetricStructuredName structuredName = new MetricStructuredName();
structuredName.setName(aggregatorName);
structuredName.setContext(ImmutableMap.of("step", stepName));
update.setName(structuredName);
jobMetrics.setMetrics(ImmutableList.of(update));
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
AggregatorValues<Long> values = job.getAggregatorValues(aggregator);
assertThat(values.getValuesAtSteps(), hasEntry(fullName, stepValue));
assertThat(values.getValuesAtSteps().size(), equalTo(1));
assertThat(values.getValues(), contains(stepValue));
assertThat(values.getTotalValue(combineFn), equalTo(Long.valueOf(stepValue)));
}
@Test
public void testGetAggregatorValuesWithMultipleMetricUpdatesReturnsCollection()
throws IOException, AggregatorRetrievalException {
CombineFn<Long, long[], Long> combineFn = new Sum.SumLongFn();
String aggregatorName = "agg";
Aggregator<Long, Long> aggregator = new TestAggregator<>(combineFn, aggregatorName);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> otherTransform = mock(PTransform.class);
String otherStepName = "s88";
String otherFullName = "Spam/Ham/Eggs";
AppliedPTransform<?, ?, ?> otherAppliedTransform =
appliedPTransform(otherFullName, otherTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(
aggregator, pTransform, aggregator, otherTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(
appliedTransform, stepName, otherAppliedTransform, otherStepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
JobMetrics jobMetrics = new JobMetrics();
when(getMetrics.execute()).thenReturn(jobMetrics);
MetricUpdate updateOne = new MetricUpdate();
long stepValue = 1234L;
updateOne.setScalar(new BigDecimal(stepValue));
MetricStructuredName structuredNameOne = new MetricStructuredName();
structuredNameOne.setName(aggregatorName);
structuredNameOne.setContext(ImmutableMap.of("step", stepName));
updateOne.setName(structuredNameOne);
MetricUpdate updateTwo = new MetricUpdate();
long stepValueTwo = 1024L;
updateTwo.setScalar(new BigDecimal(stepValueTwo));
MetricStructuredName structuredNameTwo = new MetricStructuredName();
structuredNameTwo.setName(aggregatorName);
structuredNameTwo.setContext(ImmutableMap.of("step", otherStepName));
updateTwo.setName(structuredNameTwo);
jobMetrics.setMetrics(ImmutableList.of(updateOne, updateTwo));
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
AggregatorValues<Long> values = job.getAggregatorValues(aggregator);
assertThat(values.getValuesAtSteps(), hasEntry(fullName, stepValue));
assertThat(values.getValuesAtSteps(), hasEntry(otherFullName, stepValueTwo));
assertThat(values.getValuesAtSteps().size(), equalTo(2));
assertThat(values.getValues(), containsInAnyOrder(stepValue, stepValueTwo));
assertThat(values.getTotalValue(combineFn), equalTo(Long.valueOf(stepValue + stepValueTwo)));
}
@Test
public void testGetAggregatorValuesWithUnrelatedMetricUpdateIgnoresUpdate()
throws IOException, AggregatorRetrievalException {
CombineFn<Long, long[], Long> combineFn = new Sum.SumLongFn();
String aggregatorName = "agg";
Aggregator<Long, Long> aggregator = new TestAggregator<>(combineFn, aggregatorName);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(aggregator, pTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(appliedTransform, stepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
JobMetrics jobMetrics = new JobMetrics();
when(getMetrics.execute()).thenReturn(jobMetrics);
MetricUpdate ignoredUpdate = new MetricUpdate();
ignoredUpdate.setScalar(null);
MetricStructuredName ignoredName = new MetricStructuredName();
ignoredName.setName("ignoredAggregator.elementCount.out0");
ignoredName.setContext(null);
ignoredUpdate.setName(ignoredName);
jobMetrics.setMetrics(ImmutableList.of(ignoredUpdate));
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
AggregatorValues<Long> values = job.getAggregatorValues(aggregator);
assertThat(values.getValuesAtSteps().entrySet(), empty());
assertThat(values.getValues(), empty());
}
@Test
public void testGetAggregatorValuesWithUnusedAggregatorThrowsException()
throws AggregatorRetrievalException {
Aggregator<?, ?> aggregator = mock(Aggregator.class);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of().asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("not used in this pipeline");
job.getAggregatorValues(aggregator);
}
@Test
public void testGetAggregatorValuesWhenClientThrowsExceptionThrowsAggregatorRetrievalException()
throws IOException, AggregatorRetrievalException {
CombineFn<Long, long[], Long> combineFn = new Sum.SumLongFn();
String aggregatorName = "agg";
Aggregator<Long, Long> aggregator = new TestAggregator<>(combineFn, aggregatorName);
@SuppressWarnings("unchecked")
PTransform<PInput, POutput> pTransform = mock(PTransform.class);
String stepName = "s1";
String fullName = "Foo/Bar/Baz";
AppliedPTransform<?, ?, ?> appliedTransform = appliedPTransform(fullName, pTransform);
DataflowAggregatorTransforms aggregatorTransforms = new DataflowAggregatorTransforms(
ImmutableSetMultimap.<Aggregator<?, ?>, PTransform<?, ?>>of(aggregator, pTransform).asMap(),
ImmutableMap.<AppliedPTransform<?, ?, ?>, String>of(appliedTransform, stepName));
GetMetrics getMetrics = mock(GetMetrics.class);
when(mockJobs.getMetrics(PROJECT_ID, JOB_ID)).thenReturn(getMetrics);
IOException cause = new IOException();
when(getMetrics.execute()).thenThrow(cause);
Get getState = mock(Get.class);
when(mockJobs.get(PROJECT_ID, JOB_ID)).thenReturn(getState);
Job modelJob = new Job();
when(getState.execute()).thenReturn(modelJob);
modelJob.setCurrentState(State.RUNNING.toString());
DataflowPipelineJob job =
new DataflowPipelineJob(PROJECT_ID, JOB_ID, mockWorkflowClient, aggregatorTransforms);
thrown.expect(AggregatorRetrievalException.class);
thrown.expectCause(is(cause));
thrown.expectMessage(aggregator.toString());
thrown.expectMessage("when retrieving Aggregator values for");
job.getAggregatorValues(aggregator);
}
private static class TestAggregator<InT, OutT> implements Aggregator<InT, OutT> {
private final CombineFn<InT, ?, OutT> combineFn;
private final String name;
public TestAggregator(CombineFn<InT, ?, OutT> combineFn, String name) {
this.combineFn = combineFn;
this.name = name;
}
@Override
public void addValue(InT value) {
throw new AssertionError();
}
@Override
public String getName() {
return name;
}
@Override
public CombineFn<InT, ?, OutT> getCombineFn() {
return combineFn;
}
}
private AppliedPTransform<?, ?, ?> appliedPTransform(
String fullName, PTransform<PInput, POutput> transform) {
return AppliedPTransform.of(fullName, mock(PInput.class), mock(POutput.class), transform);
}
}
| [
"[email protected]"
] | |
f538109cc1707389538f427bc23f15d262b5bc99 | 45b489697f33737a3512042246031d65e05cca1f | /Blog/src/main/java/com/threeFarmer/dao/common/IBaseDao.java | ba90e639e051de7929996241c3eef151a32c3410 | [] | no_license | WeBlogNew/Blog | 77e44bf78d9a8c74312f26f2a4ceb4d62d5cd32e | 7b42dc38c972260acca34f9cd3605c3663bebb27 | refs/heads/master | 2020-03-25T10:15:09.501066 | 2018-08-06T07:13:20 | 2018-08-06T07:13:20 | 143,688,623 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 326 | java | package com.threeFarmer.dao.common;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 基础DAO接口
*/
public interface IBaseDao<T> {
T findById(@Param("id") Integer id);
int save(T entity);
int update(T entity);
int delete(@Param("id") Integer id);
List<T> allList();
}
| [
"[email protected]"
] | |
8cfe82e8575709ea376b88cf46054f0ce4709359 | 26b7f30c6640b8017a06786e4a2414ad8a4d71dd | /src/number_of_direct_superinterfaces/i2469.java | 1c1057dcd22b3fd0aeb78c9a1eadeca298061924 | [] | no_license | vincentclee/jvm-limits | b72a2f2dcc18caa458f1e77924221d585f23316b | 2fd1c26d1f7984ea8163bc103ad14b6d72282281 | refs/heads/master | 2020-05-18T11:18:41.711400 | 2014-09-14T04:25:18 | 2014-09-14T04:25:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 68 | java | package number_of_direct_superinterfaces;
public interface i2469 {} | [
"[email protected]"
] | |
2b1f4f7b8ee67e0bc753be851e28d0167fd53a56 | b0bf62b90ca33d9ab8b1f670a501ed6643590db8 | /Exemplos/src/exemploComposite2/Elemento.java | 8f01fa758d3d7437f3226a64ef7a3df0cfa3b068 | [] | no_license | SayuriJodai/AS-ADS | 8e2d8320bdfd2920d7cbd21ebaa11de3ac906089 | 748adcb64ddf517e1dd0405e42c1de976eaed3b0 | refs/heads/master | 2020-03-27T00:29:10.960617 | 2018-08-22T00:55:43 | 2018-08-22T00:55:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 308 | java | package exemploComposite2;
public abstract class Elemento implements IElemento {
private String nome;
public Elemento(String nome) {
this.nome = nome;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
| [
"[email protected]"
] | |
a8c1fa7b8ce22f0691eace77b4c3c0c50abec237 | 30b14344d4abb01514cee567d736ee10fe86bb19 | /springmvc-03-annotation/src/main/java/com/kuang/controller/HelloController.java | 7465257be47005dca9c190c8f587d21d90d160a6 | [] | no_license | zhangqi887/SpringMVC_Study | be1db458a71d9886ca173c6708286d941f509d73 | 8c70ba73b788b556c6c49ff169d28aa34d642729 | refs/heads/master | 2023-02-19T16:13:14.168707 | 2020-08-03T02:56:58 | 2020-08-03T02:56:58 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 592 | java | package com.kuang.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/hello")
public class HelloController {
// localhost:8080/hello/h1
@RequestMapping("/h1")
public String hello(Model model) {
// 封装数据
// 在model中添加的值，可以在jsp页面直接获取
model.addAttribute("msg", "Hello SpringMVC");
// 会被视图解析器封装成 /web-inf/jsp/hello.jsp
return "hello";
}
}
| [
"[email protected]"
] | |
eee475a3756f4725773fb3e1d90316b785a86895 | 482bce12fe1566586bffaf618dcb38d0ca5431b7 | /app/src/test/java/de/triology/universeadm/mail/MailSenderTest.java | a8ff73a1d7c7baddf6ae5c85feab76ae491965aa | [
"MIT"
] | permissive | cloudogu/usermgt | d0868b25e0b4a810e93414e25c51bd3254733a89 | 0e3f88fd9acd52dd6b7718ffd193a0c4c1f74a17 | refs/heads/develop | 2023-09-02T16:49:03.096688 | 2023-08-09T10:50:57 | 2023-08-09T10:50:57 | 39,503,636 | 1 | 2 | MIT | 2023-09-11T12:28:55 | 2015-07-22T11:59:23 | Java | UTF-8 | Java | false | false | 3,004 | java | package de.triology.universeadm.mail;
import de.triology.universeadm.configuration.ApplicationConfiguration;
import de.triology.universeadm.user.User;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Matchers;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Session;
import java.io.IOException;
import java.util.ArrayList;
import static org.mockito.Mockito.*;
public class MailSenderTest {
public static final String TEST = "test";
private static final String MAIL_CONTENT = "Willkommen zum Cloudogu Ecosystem!\n" +
"Dies ist ihr Benutzeraccount\n" +
"Benutzername = %s\n" +
"Passwort = %s\n" +
"Bei der ersten Anmeldung müssen sie ihr Passwort ändern\n";
private MailSender.MessageBuilder messageBuilder;
private MailSender.TransportSender transportSender;
private Message message;
private MailSender mailSender;
private ApplicationConfiguration applicationConfig;
private final User user = new User(
"Tester",
"Tester",
"Tes",
"Ter",
"[email protected]",
"temp",
true,
new ArrayList<String>());
@Before
public void setUp() {
this.message = mock(Message.class);
this.messageBuilder = mock(MailSender.MessageBuilder.class);
this.transportSender = mock(MailSender.TransportSender.class);
this.applicationConfig = mock(ApplicationConfiguration.class);
this.mailSender = new MailSender(this.messageBuilder, this.transportSender, this.applicationConfig);
when(this.messageBuilder.build(Matchers.<Session>any())).thenReturn(this.message);
when(applicationConfig.getHost()).thenReturn("postifx");
when(applicationConfig.getPort()).thenReturn("25");
}
@Test
public void sendMailSuccessful() throws MessagingException, IOException {
String content = String.format(MAIL_CONTENT, user.getUsername(), TEST);
this.mailSender.sendMail(TEST, content, user.getMail());
ArgumentCaptor<Multipart> argument = ArgumentCaptor.forClass(Multipart.class);
verify(message).setContent(argument.capture());
String actualMsgBodyContent = argument.getValue().getBodyPart(0).getContent().toString();
Assert.assertEquals(content, actualMsgBodyContent);
verify(this.transportSender, times(1)).send(Matchers.<Message>any());
}
@Test(expected = NullPointerException.class)
public void nullValueInMethodCall() throws MessagingException {
this.mailSender.sendMail(null, null, null);
}
@Test(expected = IllegalArgumentException.class)
public void InvalidMailMethodCall() throws MessagingException {
String content = String.format(MAIL_CONTENT, user.getUsername(), TEST);
this.mailSender.sendMail(TEST, content, TEST);
}
}
| [
"[email protected]"
] | |
908f6c61e5fdb68d2f447cc7b7a48d8096c71569 | dfe5caf190661c003619bfe7a7944c527c917ee4 | /src/main/java/com/vmware/vim25/VirtualMachineSnapshotTree.java | 63aa7cbc9a75f82345e9d3910faad6b58d73c2ef | [
"BSD-3-Clause"
] | permissive | timtasse/vijava | c9787f9f9b3116a01f70a89d6ea29cc4f6dc3cd0 | 5d75bc0bd212534d44f78e5a287abf3f909a2e8e | refs/heads/master | 2023-06-01T08:20:39.601418 | 2022-10-31T12:43:24 | 2022-10-31T12:43:24 | 150,118,529 | 4 | 1 | BSD-3-Clause | 2023-05-01T21:19:53 | 2018-09-24T14:46:15 | Java | UTF-8 | Java | false | false | 3,979 | java | /*================================================================================
Copyright (c) 2013 Steve Jin. All Rights Reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of VMware, Inc. nor the names of its contributors may be used
to endorse or promote products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================================================*/
package com.vmware.vim25;
import java.util.Calendar;
/**
* @author Steve Jin (http://www.doublecloud.org)
* @version 5.1
*/
@SuppressWarnings("all")
public class VirtualMachineSnapshotTree extends DynamicData {
public ManagedObjectReference snapshot;
public ManagedObjectReference vm;
public String name;
public String description;
public Integer id;
public Calendar createTime;
public VirtualMachinePowerState state;
public boolean quiesced;
public String backupManifest;
public VirtualMachineSnapshotTree[] childSnapshotList;
public Boolean replaySupported;
public ManagedObjectReference getSnapshot() {
return this.snapshot;
}
public ManagedObjectReference getVm() {
return this.vm;
}
public String getName() {
return this.name;
}
public String getDescription() {
return this.description;
}
public Integer getId() {
return this.id;
}
public Calendar getCreateTime() {
return this.createTime;
}
public VirtualMachinePowerState getState() {
return this.state;
}
public boolean isQuiesced() {
return this.quiesced;
}
public String getBackupManifest() {
return this.backupManifest;
}
public VirtualMachineSnapshotTree[] getChildSnapshotList() {
return this.childSnapshotList;
}
public Boolean getReplaySupported() {
return this.replaySupported;
}
public void setSnapshot(ManagedObjectReference snapshot) {
this.snapshot=snapshot;
}
public void setVm(ManagedObjectReference vm) {
this.vm=vm;
}
public void setName(String name) {
this.name=name;
}
public void setDescription(String description) {
this.description=description;
}
public void setId(Integer id) {
this.id=id;
}
public void setCreateTime(Calendar createTime) {
this.createTime=createTime;
}
public void setState(VirtualMachinePowerState state) {
this.state=state;
}
public void setQuiesced(boolean quiesced) {
this.quiesced=quiesced;
}
public void setBackupManifest(String backupManifest) {
this.backupManifest=backupManifest;
}
public void setChildSnapshotList(VirtualMachineSnapshotTree[] childSnapshotList) {
this.childSnapshotList=childSnapshotList;
}
public void setReplaySupported(Boolean replaySupported) {
this.replaySupported=replaySupported;
}
} | [
"[email protected]"
] | |
56436a8e08023eeb5fe6c0c5e856b2be435f06ae | c3825017e56ea81f7ec94420007077bfc521bec1 | /src/main/java/com/sky/workflow/service/impl/CmFieldInfoTableServiceImpl.java | c2270afffe943cce9f664290131805eaa7490357 | [] | no_license | nswt2018/sky-wf-engine | cd8dde16c951af1f211dd035ba70ff1d1cc1beed | 35f0846ae8ff30a6e2806a744019b8f4ab7a2989 | refs/heads/master | 2020-04-11T01:44:21.112307 | 2019-01-09T01:56:01 | 2019-01-09T01:56:01 | 161,424,885 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 411 | java | package com.sky.workflow.service.impl;
import org.springframework.stereotype.Service;
import com.sky.core.base.service.impl.BaseServiceImpl;
import com.sky.workflow.model.CmFieldInfoTable;
import com.sky.workflow.service.ICmFieldInfoTableService;
@Service("CmFieldInfoTableService")
public class CmFieldInfoTableServiceImpl extends BaseServiceImpl<CmFieldInfoTable> implements ICmFieldInfoTableService {
}
| [
"[email protected]"
] | |
1125bdac1b1f8f451c6f31ac99ead326e27847f8 | 395ac8ead306020f338495b6f44a52bffb919a92 | /Ch7/OOP2/Composition/Main.java | 84c341ef1d3cb3a76bb13c24fbc4ddea1ee08c35 | [] | no_license | cstoicescu/JavaCourse | 77f12d91a420b391e2f01ec648e16806f946d81f | 3f01862479eaae9ea682f14fb9b8ad0f68601969 | refs/heads/master | 2021-05-17T17:30:48.202483 | 2020-04-22T17:41:32 | 2020-04-22T17:41:32 | 250,896,937 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 701 | java | package Ch7.OOP2.Composition;
public class Main {
public static void main(String[] args) {
Dimensions dimensions = new Dimensions(20,20,5);
Case theCase = new Case("2208","Dell","240V",dimensions);
Monitor theMonitor = new Monitor("27 inch","Acer",27,new Resolution(2540,1440));
Motherboard theMotherboard = new Motherboard("BJ-200","Asus",4,6,"v.2.44");
Computer pc = new Computer(theCase,theMonitor,theMotherboard);
pc.getTheCase().powerButton();
pc.powerUpAndDown();
pc.getTheMotherboard().loadProgram("Windows 10");
pc.openPaint();
pc.powerUpAndDown();
// Idea : Implement a menu , pc specs
}
}
| [
"[email protected]"
] | |
dcffefa9a45342cbc812c1be0ea7b8c0fccb550f | eb2d7a70f5cf06ece65c3621a61f5d7a250cf277 | /src/main/java/bitoflife/chatterbean/aiml/Em.java | 499f255aa73ba7f3338ef125bbc2b9db2778b09d | [
"Apache-2.0"
] | permissive | daicx/alice-bot-cn | 6115f6cd71a7f7fe8ceeca708b83c4e8561b4553 | 3b86605f1aaaeb209fb8e6bdb72acd28830790be | refs/heads/master | 2020-07-16T17:30:24.426115 | 2019-12-17T02:42:07 | 2019-12-17T02:42:07 | 205,832,823 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 363 | java | package bitoflife.chatterbean.aiml;
import bitoflife.chatterbean.Match;
import org.xml.sax.Attributes;
public class Em extends TemplateElement
{
/*
Constructors
*/
public Em(Attributes attributes)
{
}
public Em(Object... children)
{
super(children);
}
/*
Methods
*/
public String process(Match match)
{
return "";
}
} | [
"[email protected]"
] | |
833b773af07f452e878aafe78760534b21e0440b | 9399d8807299c10505472903f4836913c78f4fa8 | /app/src/main/java/com/example/jackle91/myposservice/CreateTicket.java | 7a1a0e7a8a7857dcc319b8806620f10591588dfe | [] | no_license | jackle991/MyPOSservice | 97244af36cf376a0c2b1941b3b1793d2ba7bdb3f | d9a30b44062f3c4d2d367b981ac7e414d462ed73 | refs/heads/master | 2022-12-12T22:42:14.522267 | 2020-09-02T20:31:00 | 2020-09-02T20:31:00 | 291,882,124 | 0 | 0 | null | 2020-09-01T18:46:08 | 2020-09-01T03:04:57 | Java | UTF-8 | Java | false | false | 3,470 | java | package com.example.jackle91.myposservice;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.example.jackle91.myposservice.R;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class CreateTicket extends AppCompatActivity {
TextView responseText;
EditText ticketNumberText;
EditText storeIdText;
EditText businessDateText;
EditText totalPriceText;
Button submitButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.create_ticket);
responseText = findViewById(R.id.responseText);
ticketNumberText = (EditText)findViewById(R.id.ticketNumber);
storeIdText = (EditText)findViewById(R.id.storeId);
businessDateText = (EditText)findViewById(R.id.businessDate);
totalPriceText = (EditText)findViewById(R.id.totalPrice);
submitButton = (Button)findViewById(R.id.submitButton);
// Log.i("****ticketNumber**** ", ticketNumberText.getText().toString());
// Log.i("****StoreID**** ", storeIdText.getText().toString());
submitButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
String ticketNumber = ticketNumberText.getText().toString();
String storeId = storeIdText.getText().toString();
String businessDate = businessDateText.getText().toString();
String totalPrice = totalPriceText.getText().toString();
// System.out.println("****ticketNumber**** " + ticketNumber);
// System.out.println("****StoreId**** " + storeId);
// System.out.println("****BusinessDate**** " + businessDate);
// System.out.println("****TotalPrice**** " + totalPrice);
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://192.168.1.28:8080/")
.addConverterFactory(GsonConverterFactory.create())
.build();
TicketApi ticketApi = retrofit.create(TicketApi.class);
Ticket ticket = new Ticket(ticketNumber, storeId, businessDate, totalPrice);
Call<Ticket> call = ticketApi.postTicket(ticket);
call.enqueue(new Callback<Ticket>() {
@Override
public void onResponse(Call<Ticket> call, Response<Ticket> response) {
if (!response.isSuccessful()) {
responseText.setText("Code: " + response.code());
// responseText.setText("Code: " + ticketNumberText.getText().toString());
return;
}
// Ticket t = response.body();
responseText.setText("Ticket Created Successful");
}
@Override
public void onFailure(Call<Ticket> call, Throwable t) {
responseText.setText(t.getMessage());
}
});
}
});
}
} | [
"[email protected]"
] | |
51ecc5071568c7183d9ec9ab538d2121f4be5b95 | f4762a908e49f7aaa177378c2ebdf7b985180e2b | /sources/android/support/constraint/solver/Cache.java | 355eee08d6a474708838500be9f5b4cbc8783ae6 | [
"MIT"
] | permissive | PixalTeam/receiver_android | 76f5b0a7a8c54d83e49ad5921f640842547a171f | d4aa75f9021a66262a9a267edd5bc25509677248 | refs/heads/master | 2020-12-03T08:49:57.484377 | 2020-01-01T20:38:04 | 2020-01-01T20:38:04 | 231,260,295 | 0 | 0 | MIT | 2020-11-15T12:46:40 | 2020-01-01T20:25:18 | Java | UTF-8 | Java | false | false | 254 | java | package android.support.constraint.solver;
public class Cache {
Pool<ArrayRow> arrayRowPool = new SimplePool(256);
SolverVariable[] mIndexedVariables = new SolverVariable[32];
Pool<SolverVariable> solverVariablePool = new SimplePool(256);
}
| [
"[email protected]"
] | |
4d6d7f9487f46b4e645c5f82c55ebb80f58e906a | 21d2cee9c448e466092559501900b32a96ce9748 | /edu.uci.isr.bna4/src/edu/uci/isr/bna4/things/labels/BoxedLabelThingPeer.java | bdf7288ba54a4cd7b5701c76b9465d5df4b36404 | [] | no_license | zheng3/AS | aa89acf9dc260442dee6b9816e2c5e9ecf001324 | 9549eb811fc0e1ff6bade062a933485edb919e4d | refs/heads/master | 2020-05-19T21:56:26.979488 | 2015-07-01T12:19:41 | 2015-07-01T12:19:41 | 38,369,692 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,450 | java | package edu.uci.isr.bna4.things.labels;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.TextLayout;
import edu.uci.isr.bna4.AbstractThingPeer;
import edu.uci.isr.bna4.BNAUtils;
import edu.uci.isr.bna4.IBNAView;
import edu.uci.isr.bna4.IThing;
import edu.uci.isr.bna4.ResourceUtils;
import edu.uci.isr.widgets.swt.constants.FontStyle;
import edu.uci.isr.widgets.swt.constants.HorizontalAlignment;
import edu.uci.isr.widgets.swt.constants.VerticalAlignment;
public class BoxedLabelThingPeer
extends AbstractThingPeer{
protected BoxedLabelThing t;
protected TextLayoutCache textLayoutCache = null;
public BoxedLabelThingPeer(IThing t){
super(t);
if(!(t instanceof BoxedLabelThing)){
throw new IllegalArgumentException("BoxedLabelThingPeer can only peer for BoxedLabelThing");
}
this.t = (BoxedLabelThing)t;
}
@Override
public void draw(IBNAView view, GC g){
Rectangle localBoundingBox = BNAUtils.worldToLocal(view.getCoordinateMapper(), BNAUtils.normalizeRectangle(t.getBoundingBox()));
if(!g.getClipping().intersects(localBoundingBox)){
return;
}
String text = t.getText();
if(text == null || text.trim().length() == 0){
return;
}
Color fg = ResourceUtils.getColor(getDisplay(), t.getColor());
if(fg == null){
fg = g.getDevice().getSystemColor(SWT.COLOR_BLACK);
}
g.setForeground(fg);
String fontName = t.getFontName();
int fontSize = t.getFontSize();
FontStyle fontStyle = t.getFontStyle();
boolean dontIncreaseFontSize = t.getDontIncreaseFontSize();
VerticalAlignment verticalAlignment = t.getVerticalAlignment();
HorizontalAlignment horizontalAlignment = t.getHorizontalAlignment();
if(textLayoutCache == null){
textLayoutCache = new TextLayoutCache(getDisplay());
}
textLayoutCache.setIncreaseFontSize(!dontIncreaseFontSize);
textLayoutCache.setText(text);
textLayoutCache.setFont(ResourceUtils.getFont(getDisplay(), fontName, fontSize, fontStyle));
{
/*
* The size of the local bounding box may differ slightly depending
* on the world origin. This causes excessive recalculation of the
* text layout, which is not really necessary. To overcome this, the
* width and height of the layout are only changed if they differ
* significantly from what they were before.
*/
Point oldSize = textLayoutCache.getSize();
Point size = new Point(localBoundingBox.width, localBoundingBox.height);
int dx = size.x - oldSize.x;
int dy = size.y - oldSize.y;
if(0 <= dx && dx <= 1 && 0 <= dy && dy <= 1){
size = oldSize;
}
textLayoutCache.setSize(size);
}
textLayoutCache.setAlignment(horizontalAlignment.toSWT());
TextLayout tl = textLayoutCache.getTextLayout();
if(tl != null){
Rectangle tlBounds = tl.getBounds();
int x = localBoundingBox.x;
switch(horizontalAlignment){
case LEFT:
break;
case CENTER:
x += (localBoundingBox.width - tlBounds.width) / 2;
break;
case RIGHT:
x += localBoundingBox.width - tlBounds.width;
break;
}
int y = localBoundingBox.y;
switch(verticalAlignment){
case TOP:
break;
case MIDDLE:
y += (localBoundingBox.height - tlBounds.height) / 2;
break;
case BOTTOM:
y += localBoundingBox.height - tlBounds.height;
break;
}
tl.draw(g, x, y);
}
else{
drawFakeLines(g, localBoundingBox);
}
}
private void drawFakeLines(GC g, Rectangle localBoundingBox){
g.setLineStyle(SWT.LINE_DASHDOT);
if(localBoundingBox.width >= 3){
if(localBoundingBox.height >= 1){
int y = localBoundingBox.y + localBoundingBox.height / 2;
g.drawLine(localBoundingBox.x + 1, y, localBoundingBox.x + localBoundingBox.width - 2, y);
}
if(localBoundingBox.height > 5){
int y = localBoundingBox.y + localBoundingBox.height / 2 - 2;
g.drawLine(localBoundingBox.x + 1, y, localBoundingBox.x + localBoundingBox.width - 2, y);
y += 4;
g.drawLine(localBoundingBox.x + 1, y, localBoundingBox.x + localBoundingBox.width - 2, y);
}
}
}
@Override
public boolean isInThing(IBNAView view, int worldX, int worldY){
return BNAUtils.isWithin(t.getBoundingBox(), worldX, worldY);
}
}
| [
"[email protected]"
] | |
ddb433af9a97c18f6bf05ae9d8cee26e8e7378a0 | 788c95f6c757e8e01b8b8f51bda68f770e15689c | /src/com/moviesite/hibernate/entity/Review.java | d98c32d76bc0f26544daeda8ae06ffa8cb4053a8 | [] | no_license | methmal1997/HIbernate | ec6ca430204afbef4480fe369fa5a43e0c5fed19 | 5f6f733b224b3f6edd209b9e5292a5ecb356eb41 | refs/heads/main | 2023-07-05T17:17:18.305098 | 2021-08-23T15:07:07 | 2021-08-23T15:07:07 | 399,141,112 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,344 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.moviesite.hibernate.entity;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.UniqueConstraint;
/**
*
* @author ASUS
*/
@Entity
public class Review implements Serializable {
private int idreview;
private int rate;
private Purchased purchased;
private Date rateDate;
private String discription;
private Movie movie;
public Review() {
}
public Review(int rate, String discription, Movie movie) {
this.rate = rate;
this.discription = discription;
this.movie = movie;
}
public int getRate() {
return rate;
}
public void setRate(int rate) {
this.rate = rate;
}
@ManyToOne
@JoinColumn(name = "Id")
public Purchased getPurchased() {
return purchased;
}
public void setPurchased(Purchased purchased) {
this.purchased = purchased;
}
@Temporal(javax.persistence.TemporalType.DATE)
public Date getRateDate() {
return rateDate;
}
public void setRateDate(Date rateDate) {
this.rateDate = rateDate;
}
public String getDiscription() {
return discription;
}
public void setDiscription(String discription) {
this.discription = discription;
}
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name="MovieId")
public Movie getMovie() {
return movie;
}
public void setMovie(Movie movie) {
this.movie = movie;
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public int getIdreview() {
return idreview;
}
public void setIdreview(int idreview) {
this.idreview = idreview;
}
}
| [
"[email protected]"
] | |
cc8c4aa8c70d47e3dbbb88bea5cfcfb216aefded | 7dfb1538fd074b79a0f6a62674d4979c7c55fd6d | /src/day35/StringToIntegerparsing.java | 7d3b678f663d9ab25e905c95c9c8682a55524c6a | [] | no_license | kutluduman/Java-Programming | 424a4ad92e14f2d4cc700c8a9352ff7408aa993f | d55b8a61ab3a654f954e33db1cb244e36bbcc7da | refs/heads/master | 2022-04-18T03:54:50.219846 | 2020-04-18T05:45:45 | 2020-04-18T05:45:45 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,753 | java | package day35;
public class StringToIntegerparsing {
public static void main(String[] args) {
/**
* I have a employee ID : "FB-457"
* give me the employee number and store it into a number
*/
// String strNum = "100";
// int num = Integer.parseInt(strNum);
//
// System.out.println("num = " + num);
//
// String empID = "FB-457";
// int empID = Integer.parseInt(empID);
/**
* Integer class is class coming from java.lang package
* It's primarily used for wrapping up primitive value and treat it object
* what we will focus here i s though
* many useful static methods it provide already
* parseInt is a static method of Integer class
* It will turn a String that has only numbers and return int result
* if we have any non-numerical character ---> It will throw NumberFormatException
*/
// String[] empIDSplit = empID.s("-");
// String idStr = IDSplit[1];
// int id = Integer.parseInt(idStr);
//
// System.out.println("id = " + id);
// I have a String called twoNumbers
String twoNumbers = "100,600";
// I want to add them and give the result
String[] twoNumbersSplit = twoNumbers.split(",");
int num1 = Integer.parseInt(twoNumbersSplit[0]);
int num2 = Integer.parseInt(twoNumbersSplit[1]);
int sum = num1 + num2;
System.out.println("sum = " + sum);
int num1_1 = Integer.valueOf(twoNumbers.substring(0,3)) ;
int num2_1= Integer.valueOf(twoNumbers.substring(4));
int sum_1 = num1_1+num2_1;
System.out.println("sum_1 = " + sum_1);
}
}
| [
"[email protected]"
] | |
40f0f74281bd65c68490ffe80c3fa3b897abb2e1 | ec9d221cea6eac53d902970149fda556ab457ca3 | /src/main/java/com/orasystems/libs/utils/preferences/PreferencesUtil.java | 07319e6ae0b268177d8d94ff7f2cad0535d81f35 | [] | no_license | orasystems/OrasystemsUtilLibrary | 528696e6015cec8564d2a45e53baa3edb9c73943 | 61913851c3e53b0f4d8a43ba47009f2061e6b33b | refs/heads/master | 2021-01-10T05:58:16.052064 | 2016-02-25T14:34:58 | 2016-02-25T14:34:58 | 52,529,795 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 521 | java | package com.orasystems.libs.utils.preferences;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
public class PreferencesUtil {
public static SharedPreferences.Editor getPrefEditor(Context context){
SharedPreferences preference = PreferenceManager.getDefaultSharedPreferences(context);
return preference.edit();
}
public static SharedPreferences getPref(Context context){
return PreferenceManager.getDefaultSharedPreferences(context);
}
}
| [
"[email protected]"
] | |
551d57817c2688ccae2e599c1b4f160ef8ab6e96 | ddac11ed921cf1b6a8b4f8eb037ef69fe632b183 | /src/main/java/org/java/spring/boot/demo/controller/DemoController.java | 878f0dfd815151b8c8a73e334de6d8b01fa83fb1 | [] | no_license | a969146049/springTest | 014b71bc4a5fbaac67f538a4d5cd2580751e1ef3 | 664dc4933bc393cc0fdd2718bae9a013e0fc43a2 | refs/heads/master | 2020-03-22T19:57:06.495054 | 2018-07-11T10:40:43 | 2018-07-11T10:40:43 | 140,563,147 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 390 | java | package org.java.spring.boot.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* Created by Administrator on 18/7/9.
*/
@RestController
public class DemoController {
@RequestMapping(value = "hi")
public String sayHi(){
return "Hellor Spring Boot";
}
}
| [
"[email protected]"
] | |
70dec8a8013d710a0031f3a04dfc33f90a962b7a | 243979a80371e53e57b284d321caa78054fa9eb6 | /Leyou-item/Leyou-item-service/src/main/java/com/leyou/item/service/SpecificationService.java | 1ac7ec08bdabf1a0c57a3831da656ab275ad7f4e | [] | no_license | ForeverAndy/Reserch_LeYouMarket | ee53f9c985f044775e7da1c2f0234f4da4789be9 | 3794bcd2ebb71e60693c5266e314620b66773d23 | refs/heads/master | 2022-11-10T06:13:54.375423 | 2020-04-29T10:39:15 | 2020-04-29T10:39:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 725 | java | package com.leyou.item.service;
import com.leyou.item.pojo.Specification;
/**
* @Author: 98050
* Time: 2018-08-14 15:26
* Feature:
*/
public interface SpecificationService {
/**
* 根据category id查询规格参数模板
* @param cid
* @return
*/
Specification queryById(Long cid);
/**
* 添加规格参数模板
* @param specification
*/
void saveSpecification(Specification specification);
/**
* 修改规格参数模板
* @param specification
*/
void updateSpecification(Specification specification);
/**
* 删除规格参数模板
* @param specification
*/
void deleteSpecification(Specification specification);
}
| [
"[email protected]"
] | |
4fbbf78e2425e5f4dcbef3c6641b225998eae3e7 | 065c1f648e8dd061a20147ff9c0dbb6b5bc8b9be | /eclipsejdt_cluster/16417/src_0.java | 047c44068b94c2d94ae66dcae3f891e74a70aa9a | [] | no_license | martinezmatias/GenPat-data-C3 | 63cfe27efee2946831139747e6c20cf952f1d6f6 | b360265a6aa3bb21bd1d64f1fc43c3b37d0da2a4 | refs/heads/master | 2022-04-25T17:59:03.905613 | 2020-04-15T14:41:34 | 2020-04-15T14:41:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 52,512 | java | /*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
import java.util.*;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
public class ClassScope extends Scope {
public TypeDeclaration referenceContext;
public TypeReference superTypeReference;
public ClassScope(Scope parent, TypeDeclaration context) {
super(CLASS_SCOPE, parent);
this.referenceContext = context;
}
void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {
LocalTypeBinding anonymousType = buildLocalType(enclosingType, enclosingType.fPackage);
SourceTypeBinding sourceType = referenceContext.binding;
if (supertype.isInterface()) {
sourceType.superclass = getJavaLangObject();
sourceType.superInterfaces = new ReferenceBinding[] { supertype };
} else {
sourceType.superclass = supertype;
sourceType.superInterfaces = Binding.NO_SUPERINTERFACES;
}
connectMemberTypes();
buildFieldsAndMethods();
anonymousType.faultInTypesForFieldsAndMethods();
sourceType.verifyMethods(environment().methodVerifier());
}
private void buildFields() {
if (referenceContext.fields == null) {
referenceContext.binding.setFields(Binding.NO_FIELDS);
return;
}
// count the number of fields vs. initializers
FieldDeclaration[] fields = referenceContext.fields;
int size = fields.length;
int count = 0;
for (int i = 0; i < size; i++) {
switch (fields[i].getKind()) {
case AbstractVariableDeclaration.FIELD:
case AbstractVariableDeclaration.ENUM_CONSTANT:
count++;
}
}
// iterate the field declarations to create the bindings, lose all duplicates
FieldBinding[] fieldBindings = new FieldBinding[count];
HashtableOfObject knownFieldNames = new HashtableOfObject(count);
boolean duplicate = false;
count = 0;
for (int i = 0; i < size; i++) {
FieldDeclaration field = fields[i];
if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {
if (referenceContext.binding.isInterface())
problemReporter().interfaceCannotHaveInitializers(referenceContext.binding, field);
} else {
FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers | ExtraCompilerModifiers.AccUnresolved, referenceContext.binding);
fieldBinding.id = count;
// field's type will be resolved when needed for top level types
checkAndSetModifiersForField(fieldBinding, field);
if (knownFieldNames.containsKey(field.name)) {
duplicate = true;
FieldBinding previousBinding = (FieldBinding) knownFieldNames.get(field.name);
if (previousBinding != null) {
for (int f = 0; f < i; f++) {
FieldDeclaration previousField = fields[f];
if (previousField.binding == previousBinding) {
problemReporter().duplicateFieldInType(referenceContext.binding, previousField);
previousField.binding = null;
break;
}
}
}
knownFieldNames.put(field.name, null); // ensure that the duplicate field is found & removed
problemReporter().duplicateFieldInType(referenceContext.binding, field);
field.binding = null;
} else {
knownFieldNames.put(field.name, fieldBinding);
// remember that we have seen a field with this name
if (fieldBinding != null)
fieldBindings[count++] = fieldBinding;
}
}
}
// remove duplicate fields
if (duplicate) {
FieldBinding[] newFieldBindings = new FieldBinding[fieldBindings.length];
// we know we'll be removing at least 1 duplicate name
size = count;
count = 0;
for (int i = 0; i < size; i++) {
FieldBinding fieldBinding = fieldBindings[i];
if (knownFieldNames.get(fieldBinding.name) != null) {
fieldBinding.id = count;
newFieldBindings[count++] = fieldBinding;
}
}
fieldBindings = newFieldBindings;
}
if (count != fieldBindings.length)
System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);
referenceContext.binding.setFields(fieldBindings);
}
void buildFieldsAndMethods() {
buildFields();
buildMethods();
SourceTypeBinding sourceType = referenceContext.binding;
if (sourceType.isMemberType() && !sourceType.isLocalType())
((MemberTypeBinding) sourceType).checkSyntheticArgsAndFields();
ReferenceBinding[] memberTypes = sourceType.memberTypes;
for (int i = 0, length = memberTypes.length; i < length; i++)
((SourceTypeBinding) memberTypes[i]).scope.buildFieldsAndMethods();
}
private LocalTypeBinding buildLocalType(SourceTypeBinding enclosingType, PackageBinding packageBinding) {
referenceContext.scope = this;
referenceContext.staticInitializerScope = new MethodScope(this, referenceContext, true);
referenceContext.initializerScope = new MethodScope(this, referenceContext, false);
// build the binding or the local type
LocalTypeBinding localType = new LocalTypeBinding(this, enclosingType, this.innermostSwitchCase());
referenceContext.binding = localType;
checkAndSetModifiers();
buildTypeVariables();
// Look at member types
ReferenceBinding[] memberTypeBindings = Binding.NO_MEMBER_TYPES;
if (referenceContext.memberTypes != null) {
int size = referenceContext.memberTypes.length;
memberTypeBindings = new ReferenceBinding[size];
int count = 0;
nextMember : for (int i = 0; i < size; i++) {
TypeDeclaration memberContext = referenceContext.memberTypes[i];
switch(TypeDeclaration.kind(memberContext.modifiers)) {
case TypeDeclaration.INTERFACE_DECL :
case TypeDeclaration.ANNOTATION_TYPE_DECL :
problemReporter().illegalLocalTypeDeclaration(memberContext);
continue nextMember;
}
ReferenceBinding type = localType;
// check that the member does not conflict with an enclosing type
do {
if (CharOperation.equals(type.sourceName, memberContext.name)) {
problemReporter().hidingEnclosingType(memberContext);
continue nextMember;
}
type = type.enclosingType();
} while (type != null);
// check the member type does not conflict with another sibling member type
for (int j = 0; j < i; j++) {
if (CharOperation.equals(referenceContext.memberTypes[j].name, memberContext.name)) {
problemReporter().duplicateNestedType(memberContext);
continue nextMember;
}
}
ClassScope memberScope = new ClassScope(this, referenceContext.memberTypes[i]);
LocalTypeBinding memberBinding = memberScope.buildLocalType(localType, packageBinding);
memberBinding.setAsMemberType();
memberTypeBindings[count++] = memberBinding;
}
if (count != size)
System.arraycopy(memberTypeBindings, 0, memberTypeBindings = new ReferenceBinding[count], 0, count);
}
localType.memberTypes = memberTypeBindings;
return localType;
}
void buildLocalTypeBinding(SourceTypeBinding enclosingType) {
LocalTypeBinding localType = buildLocalType(enclosingType, enclosingType.fPackage);
connectTypeHierarchy();
buildFieldsAndMethods();
localType.faultInTypesForFieldsAndMethods();
referenceContext.binding.verifyMethods(environment().methodVerifier());
}
private void buildMemberTypes(AccessRestriction accessRestriction) {
SourceTypeBinding sourceType = referenceContext.binding;
ReferenceBinding[] memberTypeBindings = Binding.NO_MEMBER_TYPES;
if (referenceContext.memberTypes != null) {
int length = referenceContext.memberTypes.length;
memberTypeBindings = new ReferenceBinding[length];
int count = 0;
nextMember : for (int i = 0; i < length; i++) {
TypeDeclaration memberContext = referenceContext.memberTypes[i];
switch(TypeDeclaration.kind(memberContext.modifiers)) {
case TypeDeclaration.INTERFACE_DECL :
case TypeDeclaration.ANNOTATION_TYPE_DECL :
if (sourceType.isNestedType()
&& sourceType.isClass() // no need to check for enum, since implicitly static
&& !sourceType.isStatic()) {
problemReporter().illegalLocalTypeDeclaration(memberContext);
continue nextMember;
}
break;
}
ReferenceBinding type = sourceType;
// check that the member does not conflict with an enclosing type
do {
if (CharOperation.equals(type.sourceName, memberContext.name)) {
problemReporter().hidingEnclosingType(memberContext);
continue nextMember;
}
type = type.enclosingType();
} while (type != null);
// check that the member type does not conflict with another sibling member type
for (int j = 0; j < i; j++) {
if (CharOperation.equals(referenceContext.memberTypes[j].name, memberContext.name)) {
problemReporter().duplicateNestedType(memberContext);
continue nextMember;
}
}
ClassScope memberScope = new ClassScope(this, memberContext);
memberTypeBindings[count++] = memberScope.buildType(sourceType, sourceType.fPackage, accessRestriction);
}
if (count != length)
System.arraycopy(memberTypeBindings, 0, memberTypeBindings = new ReferenceBinding[count], 0, count);
}
sourceType.memberTypes = memberTypeBindings;
}
private void buildMethods() {
boolean isEnum = TypeDeclaration.kind(referenceContext.modifiers) == TypeDeclaration.ENUM_DECL;
if (referenceContext.methods == null && !isEnum) {
referenceContext.binding.setMethods(Binding.NO_METHODS);
return;
}
// iterate the method declarations to create the bindings
AbstractMethodDeclaration[] methods = referenceContext.methods;
int size = methods == null ? 0 : methods.length;
// look for <clinit> method
int clinitIndex = -1;
for (int i = 0; i < size; i++) {
if (methods[i].isClinit()) {
clinitIndex = i;
break;
}
}
int count = isEnum ? 2 : 0; // reserve 2 slots for special enum methods: #values() and #valueOf(String)
MethodBinding[] methodBindings = new MethodBinding[(clinitIndex == -1 ? size : size - 1) + count];
// create special methods for enums
SourceTypeBinding sourceType = referenceContext.binding;
if (isEnum) {
methodBindings[0] = sourceType.addSyntheticEnumMethod(TypeConstants.VALUES); // add <EnumType>[] values()
methodBindings[1] = sourceType.addSyntheticEnumMethod(TypeConstants.VALUEOF); // add <EnumType> valueOf()
}
// create bindings for source methods
for (int i = 0; i < size; i++) {
if (i != clinitIndex) {
MethodScope scope = new MethodScope(this, methods[i], false);
MethodBinding methodBinding = scope.createMethod(methods[i]);
if (methodBinding != null) // is null if binding could not be created
methodBindings[count++] = methodBinding;
}
}
if (count != methodBindings.length)
System.arraycopy(methodBindings, 0, methodBindings = new MethodBinding[count], 0, count);
sourceType.tagBits &= ~TagBits.AreMethodsSorted; // in case some static imports reached already into this type
sourceType.setMethods(methodBindings);
}
SourceTypeBinding buildType(SourceTypeBinding enclosingType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
// provide the typeDeclaration with needed scopes
referenceContext.scope = this;
referenceContext.staticInitializerScope = new MethodScope(this, referenceContext, true);
referenceContext.initializerScope = new MethodScope(this, referenceContext, false);
if (enclosingType == null) {
char[][] className = CharOperation.arrayConcat(packageBinding.compoundName, referenceContext.name);
referenceContext.binding = new SourceTypeBinding(className, packageBinding, this);
} else {
char[][] className = CharOperation.deepCopy(enclosingType.compoundName);
className[className.length - 1] =
CharOperation.concat(className[className.length - 1], referenceContext.name, '$');
referenceContext.binding = new MemberTypeBinding(className, this, enclosingType);
}
SourceTypeBinding sourceType = referenceContext.binding;
environment().setAccessRestriction(sourceType, accessRestriction);
sourceType.fPackage.addType(sourceType);
checkAndSetModifiers();
buildTypeVariables();
buildMemberTypes(accessRestriction);
return sourceType;
}
private void buildTypeVariables() {
SourceTypeBinding sourceType = referenceContext.binding;
TypeParameter[] typeParameters = referenceContext.typeParameters;
// do not construct type variables if source < 1.5
if (typeParameters == null || compilerOptions().sourceLevel < ClassFileConstants.JDK1_5) {
sourceType.typeVariables = Binding.NO_TYPE_VARIABLES;
return;
}
sourceType.typeVariables = Binding.NO_TYPE_VARIABLES; // safety
if (sourceType.id == T_JavaLangObject) { // handle the case of redefining java.lang.Object up front
problemReporter().objectCannotBeGeneric(referenceContext);
return;
}
sourceType.typeVariables = createTypeVariables(typeParameters, sourceType);
sourceType.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
}
private void checkAndSetModifiers() {
SourceTypeBinding sourceType = referenceContext.binding;
int modifiers = sourceType.modifiers;
if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0)
problemReporter().duplicateModifierForType(sourceType);
ReferenceBinding enclosingType = sourceType.enclosingType();
boolean isMemberType = sourceType.isMemberType();
if (isMemberType) {
modifiers |= (enclosingType.modifiers & (ExtraCompilerModifiers.AccGenericSignature|ClassFileConstants.AccStrictfp));
// checks for member types before local types to catch local members
if (enclosingType.isInterface())
modifiers |= ClassFileConstants.AccPublic;
if (sourceType.isEnum()) {
if (!enclosingType.isStatic())
problemReporter().nonStaticContextForEnumMemberType(sourceType);
else
modifiers |= ClassFileConstants.AccStatic;
}
} else if (sourceType.isLocalType()) {
if (sourceType.isEnum()) {
problemReporter().illegalLocalTypeDeclaration(referenceContext);
sourceType.modifiers = 0;
return;
}
if (sourceType.isAnonymousType()) {
modifiers |= ClassFileConstants.AccFinal;
// set AccEnum flag for anonymous body of enum constants
if (referenceContext.allocation.type == null)
modifiers |= ClassFileConstants.AccEnum;
}
Scope scope = this;
do {
switch (scope.kind) {
case METHOD_SCOPE :
MethodScope methodScope = (MethodScope) scope;
if (methodScope.isInsideInitializer()) {
SourceTypeBinding type = ((TypeDeclaration) methodScope.referenceContext).binding;
// inside field declaration ? check field modifier to see if deprecated
if (methodScope.initializedField != null) {
// currently inside this field initialization
if (methodScope.initializedField.isViewedAsDeprecated() && !sourceType.isDeprecated())
modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
} else {
if (type.isStrictfp())
modifiers |= ClassFileConstants.AccStrictfp;
if (type.isViewedAsDeprecated() && !sourceType.isDeprecated())
modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
}
} else {
MethodBinding method = ((AbstractMethodDeclaration) methodScope.referenceContext).binding;
if (method != null) {
if (method.isStrictfp())
modifiers |= ClassFileConstants.AccStrictfp;
if (method.isViewedAsDeprecated() && !sourceType.isDeprecated())
modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
}
}
break;
case CLASS_SCOPE :
// local member
if (enclosingType.isStrictfp())
modifiers |= ClassFileConstants.AccStrictfp;
if (enclosingType.isViewedAsDeprecated() && !sourceType.isDeprecated())
modifiers |= ExtraCompilerModifiers.AccDeprecatedImplicitly;
break;
}
scope = scope.parent;
} while (scope != null);
}
// after this point, tests on the 16 bits reserved.
int realModifiers = modifiers & ExtraCompilerModifiers.AccJustFlag;
if ((realModifiers & ClassFileConstants.AccInterface) != 0) { // interface and annotation type
// detect abnormal cases for interfaces
if (isMemberType) {
final int UNEXPECTED_MODIFIERS =
~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStatic | ClassFileConstants.AccAbstract | ClassFileConstants.AccInterface | ClassFileConstants.AccStrictfp | ClassFileConstants.AccAnnotation);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
if ((realModifiers & ClassFileConstants.AccAnnotation) != 0)
problemReporter().illegalModifierForAnnotationMemberType(sourceType);
else
problemReporter().illegalModifierForMemberInterface(sourceType);
}
/*
} else if (sourceType.isLocalType()) { //interfaces cannot be defined inside a method
int unexpectedModifiers = ~(AccAbstract | AccInterface | AccStrictfp);
if ((realModifiers & unexpectedModifiers) != 0)
problemReporter().illegalModifierForLocalInterface(sourceType);
*/
} else {
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccAbstract | ClassFileConstants.AccInterface | ClassFileConstants.AccStrictfp | ClassFileConstants.AccAnnotation);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
if ((realModifiers & ClassFileConstants.AccAnnotation) != 0)
problemReporter().illegalModifierForAnnotationType(sourceType);
else
problemReporter().illegalModifierForInterface(sourceType);
}
}
modifiers |= ClassFileConstants.AccAbstract;
} else if ((realModifiers & ClassFileConstants.AccEnum) != 0) {
// detect abnormal cases for enums
if (isMemberType) { // includes member types defined inside local types
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStatic | ClassFileConstants.AccStrictfp | ClassFileConstants.AccEnum);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForMemberEnum(sourceType);
} else if (sourceType.isLocalType()) { // each enum constant is an anonymous local type
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccStrictfp | ClassFileConstants.AccFinal | ClassFileConstants.AccEnum); // add final since implicitly set for anonymous type
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForLocalEnum(sourceType);
} else {
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccStrictfp | ClassFileConstants.AccEnum);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForEnum(sourceType);
}
// what about inherited interface methods?
if ((referenceContext.bits & ASTNode.HasAbstractMethods) != 0) {
modifiers |= ClassFileConstants.AccAbstract;
} else if (!sourceType.isAnonymousType()) {
// body of enum constant must implement any inherited abstract methods
// enum type needs to implement abstract methods if one of its constants does not supply a body
checkAbstractEnum: {
TypeDeclaration typeDeclaration = this.referenceContext;
FieldDeclaration[] fields = typeDeclaration.fields;
int fieldsLength = fields == null ? 0 : fields.length;
if (fieldsLength == 0) break checkAbstractEnum; // has no constants so must implement the method itself
AbstractMethodDeclaration[] methods = typeDeclaration.methods;
int methodsLength = methods == null ? 0 : methods.length;
// TODO (kent) cannot tell that the superinterfaces are empty or that their methods are implemented
boolean definesAbstractMethod = typeDeclaration.superInterfaces != null;
for (int i = 0; i < methodsLength && !definesAbstractMethod; i++)
definesAbstractMethod = methods[i].isAbstract();
if (!definesAbstractMethod) break checkAbstractEnum; // all methods have bodies
for (int i = 0; i < fieldsLength; i++) {
FieldDeclaration fieldDecl = fields[i];
if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT)
if (!(fieldDecl.initialization instanceof QualifiedAllocationExpression))
break checkAbstractEnum;
}
// tag this enum as abstract since an abstract method must be implemented AND all enum constants define an anonymous body
// as a result, each of its anonymous constants will see it as abstract and must implement each inherited abstract method
modifiers |= ClassFileConstants.AccAbstract;
}
}
modifiers |= ClassFileConstants.AccFinal;
} else {
// detect abnormal cases for classes
if (isMemberType) { // includes member types defined inside local types
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStatic | ClassFileConstants.AccAbstract | ClassFileConstants.AccFinal | ClassFileConstants.AccStrictfp);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForMemberClass(sourceType);
} else if (sourceType.isLocalType()) {
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccAbstract | ClassFileConstants.AccFinal | ClassFileConstants.AccStrictfp);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForLocalClass(sourceType);
} else {
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccAbstract | ClassFileConstants.AccFinal | ClassFileConstants.AccStrictfp);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0)
problemReporter().illegalModifierForClass(sourceType);
}
// check that Final and Abstract are not set together
if ((realModifiers & (ClassFileConstants.AccFinal | ClassFileConstants.AccAbstract)) == (ClassFileConstants.AccFinal | ClassFileConstants.AccAbstract))
problemReporter().illegalModifierCombinationFinalAbstractForClass(sourceType);
}
if (isMemberType) {
// test visibility modifiers inconsistency, isolate the accessors bits
if (enclosingType.isInterface()) {
if ((realModifiers & (ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate)) != 0) {
problemReporter().illegalVisibilityModifierForInterfaceMemberType(sourceType);
// need to keep the less restrictive
if ((realModifiers & ClassFileConstants.AccProtected) != 0)
modifiers &= ~ClassFileConstants.AccProtected;
if ((realModifiers & ClassFileConstants.AccPrivate) != 0)
modifiers &= ~ClassFileConstants.AccPrivate;
}
} else {
int accessorBits = realModifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate);
if ((accessorBits & (accessorBits - 1)) > 1) {
problemReporter().illegalVisibilityModifierCombinationForMemberType(sourceType);
// need to keep the less restrictive so disable Protected/Private as necessary
if ((accessorBits & ClassFileConstants.AccPublic) != 0) {
if ((accessorBits & ClassFileConstants.AccProtected) != 0)
modifiers &= ~ClassFileConstants.AccProtected;
if ((accessorBits & ClassFileConstants.AccPrivate) != 0)
modifiers &= ~ClassFileConstants.AccPrivate;
} else if ((accessorBits & ClassFileConstants.AccProtected) != 0 && (accessorBits & ClassFileConstants.AccPrivate) != 0) {
modifiers &= ~ClassFileConstants.AccPrivate;
}
}
}
// static modifier test
if ((realModifiers & ClassFileConstants.AccStatic) == 0) {
if (enclosingType.isInterface())
modifiers |= ClassFileConstants.AccStatic;
} else if (!enclosingType.isStatic()) {
// error the enclosing type of a static field must be static or a top-level type
problemReporter().illegalStaticModifierForMemberType(sourceType);
}
}
sourceType.modifiers = modifiers;
}
/* This method checks the modifiers of a field.
*
* 9.3 & 8.3
* Need to integrate the check for the final modifiers for nested types
*
* Note : A scope is accessible by : fieldBinding.declaringClass.scope
*/
private void checkAndSetModifiersForField(FieldBinding fieldBinding, FieldDeclaration fieldDecl) {
int modifiers = fieldBinding.modifiers;
final ReferenceBinding declaringClass = fieldBinding.declaringClass;
if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0)
problemReporter().duplicateModifierForField(declaringClass, fieldDecl);
if (declaringClass.isInterface()) {
final int IMPLICIT_MODIFIERS = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal;
// set the modifiers
modifiers |= IMPLICIT_MODIFIERS;
// and then check that they are the only ones
if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != IMPLICIT_MODIFIERS) {
if ((declaringClass.modifiers & ClassFileConstants.AccAnnotation) != 0)
problemReporter().illegalModifierForAnnotationField(fieldDecl);
else
problemReporter().illegalModifierForInterfaceField(fieldDecl);
}
fieldBinding.modifiers = modifiers;
return;
} else if (fieldDecl.getKind() == AbstractVariableDeclaration.ENUM_CONSTANT) {
// check that they are not modifiers in source
if ((modifiers & ExtraCompilerModifiers.AccJustFlag) != 0)
problemReporter().illegalModifierForEnumConstant(declaringClass, fieldDecl);
// set the modifiers
final int IMPLICIT_MODIFIERS = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal | ClassFileConstants.AccEnum;
if (fieldDecl.initialization instanceof QualifiedAllocationExpression)
declaringClass.modifiers &= ~ClassFileConstants.AccFinal;
fieldBinding.modifiers|= IMPLICIT_MODIFIERS;
return;
}
// after this point, tests on the 16 bits reserved.
int realModifiers = modifiers & ExtraCompilerModifiers.AccJustFlag;
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccFinal | ClassFileConstants.AccStatic | ClassFileConstants.AccTransient | ClassFileConstants.AccVolatile);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
problemReporter().illegalModifierForField(declaringClass, fieldDecl);
modifiers &= ~ExtraCompilerModifiers.AccJustFlag | ~UNEXPECTED_MODIFIERS;
}
int accessorBits = realModifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate);
if ((accessorBits & (accessorBits - 1)) > 1) {
problemReporter().illegalVisibilityModifierCombinationForField(declaringClass, fieldDecl);
// need to keep the less restrictive so disable Protected/Private as necessary
if ((accessorBits & ClassFileConstants.AccPublic) != 0) {
if ((accessorBits & ClassFileConstants.AccProtected) != 0)
modifiers &= ~ClassFileConstants.AccProtected;
if ((accessorBits & ClassFileConstants.AccPrivate) != 0)
modifiers &= ~ClassFileConstants.AccPrivate;
} else if ((accessorBits & ClassFileConstants.AccProtected) != 0 && (accessorBits & ClassFileConstants.AccPrivate) != 0) {
modifiers &= ~ClassFileConstants.AccPrivate;
}
}
if ((realModifiers & (ClassFileConstants.AccFinal | ClassFileConstants.AccVolatile)) == (ClassFileConstants.AccFinal | ClassFileConstants.AccVolatile))
problemReporter().illegalModifierCombinationFinalVolatileForField(declaringClass, fieldDecl);
if (fieldDecl.initialization == null && (modifiers & ClassFileConstants.AccFinal) != 0)
modifiers |= ExtraCompilerModifiers.AccBlankFinal;
fieldBinding.modifiers = modifiers;
}
public void checkParameterizedSuperTypeCollisions() {
// check for parameterized interface collisions (when different parameterizations occur)
SourceTypeBinding sourceType = referenceContext.binding;
ReferenceBinding[] interfaces = sourceType.superInterfaces;
int count = interfaces.length;
Map invocations = new HashMap(2);
ReferenceBinding itsSuperclass = sourceType.isInterface() ? null : sourceType.superclass;
nextInterface: for (int i = 0, length = count; i < length; i++) {
ReferenceBinding one = interfaces[i];
if (one == null) continue nextInterface;
if (itsSuperclass != null && hasErasedCandidatesCollisions(itsSuperclass, one, invocations, sourceType, referenceContext)) {
interfaces[i] = null;
count--;
continue nextInterface;
}
nextOtherInterface: for (int j = 0; j < i; j++) {
ReferenceBinding two = interfaces[j];
if (two == null) continue nextOtherInterface;
if (hasErasedCandidatesCollisions(one, two, invocations, sourceType, referenceContext)) {
interfaces[i] = null;
count--;
continue nextInterface;
}
}
}
if (count < interfaces.length) {
if (count == 0) {
sourceType.superInterfaces = Binding.NO_SUPERINTERFACES;
} else {
ReferenceBinding[] newInterfaceBindings = new ReferenceBinding[count];
for (int i = 0, j = 0, l = interfaces.length; i < l; i++)
if (interfaces[i] != null)
newInterfaceBindings[j++] = interfaces[i];
sourceType.superInterfaces = newInterfaceBindings;
}
}
TypeParameter[] typeParameters = this.referenceContext.typeParameters;
nextVariable : for (int i = 0, paramLength = typeParameters == null ? 0 : typeParameters.length; i < paramLength; i++) {
TypeParameter typeParameter = typeParameters[i];
TypeVariableBinding typeVariable = typeParameter.binding;
if (typeVariable == null || !typeVariable.isValidBinding()) continue nextVariable;
TypeReference[] boundRefs = typeParameter.bounds;
if (boundRefs != null) {
boolean checkSuperclass = typeVariable.firstBound == typeVariable.superclass;
for (int j = 0, boundLength = boundRefs.length; j < boundLength; j++) {
TypeReference typeRef = boundRefs[j];
TypeBinding superType = typeRef.resolvedType;
if (superType == null || !superType.isValidBinding()) continue;
// check against superclass
if (checkSuperclass)
if (hasErasedCandidatesCollisions(superType, typeVariable.superclass, invocations, typeVariable, typeRef))
continue nextVariable;
// check against superinterfaces
for (int index = typeVariable.superInterfaces.length; --index >= 0;)
if (hasErasedCandidatesCollisions(superType, typeVariable.superInterfaces[index], invocations, typeVariable, typeRef))
continue nextVariable;
}
}
}
ReferenceBinding[] memberTypes = referenceContext.binding.memberTypes;
if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES)
for (int i = 0, size = memberTypes.length; i < size; i++)
((SourceTypeBinding) memberTypes[i]).scope.checkParameterizedSuperTypeCollisions();
}
private void checkForInheritedMemberTypes(SourceTypeBinding sourceType) {
// search up the hierarchy of the sourceType to see if any superType defines a member type
// when no member types are defined, tag the sourceType & each superType with the HasNoMemberTypes bit
// assumes super types have already been checked & tagged
ReferenceBinding currentType = sourceType;
ReferenceBinding[] interfacesToVisit = null;
int nextPosition = 0;
do {
if (currentType.hasMemberTypes()) // avoid resolving member types eagerly
return;
ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
if (itsInterfaces == null)
return; // in code assist cases when source types are added late, may not be finished connecting hierarchy
if (interfacesToVisit == null) {
interfacesToVisit = itsInterfaces;
nextPosition = interfacesToVisit.length;
} else {
int itsLength = itsInterfaces.length;
if (nextPosition + itsLength >= interfacesToVisit.length)
System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
nextInterface : for (int a = 0; a < itsLength; a++) {
ReferenceBinding next = itsInterfaces[a];
for (int b = 0; b < nextPosition; b++)
if (next == interfacesToVisit[b]) continue nextInterface;
interfacesToVisit[nextPosition++] = next;
}
}
}
} while ((currentType = currentType.superclass()) != null && (currentType.tagBits & TagBits.HasNoMemberTypes) == 0);
if (interfacesToVisit != null) {
// contains the interfaces between the sourceType and any superclass, which was tagged as having no member types
boolean needToTag = false;
for (int i = 0; i < nextPosition; i++) {
ReferenceBinding anInterface = interfacesToVisit[i];
if ((anInterface.tagBits & TagBits.HasNoMemberTypes) == 0) { // skip interface if it already knows it has no member types
if (anInterface.hasMemberTypes()) // avoid resolving member types eagerly
return;
needToTag = true;
ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
int itsLength = itsInterfaces.length;
if (nextPosition + itsLength >= interfacesToVisit.length)
System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
nextInterface : for (int a = 0; a < itsLength; a++) {
ReferenceBinding next = itsInterfaces[a];
for (int b = 0; b < nextPosition; b++)
if (next == interfacesToVisit[b]) continue nextInterface;
interfacesToVisit[nextPosition++] = next;
}
}
}
}
if (needToTag) {
for (int i = 0; i < nextPosition; i++)
interfacesToVisit[i].tagBits |= TagBits.HasNoMemberTypes;
}
}
// tag the sourceType and all of its superclasses, unless they have already been tagged
currentType = sourceType;
do {
currentType.tagBits |= TagBits.HasNoMemberTypes;
} while ((currentType = currentType.superclass()) != null && (currentType.tagBits & TagBits.HasNoMemberTypes) == 0);
}
// Perform deferred bound checks for parameterized type references (only done after hierarchy is connected)
public void checkParameterizedTypeBounds() {
TypeReference superclass = referenceContext.superclass;
if (superclass != null)
superclass.checkBounds(this);
TypeReference[] superinterfaces = referenceContext.superInterfaces;
if (superinterfaces != null)
for (int i = 0, length = superinterfaces.length; i < length; i++)
superinterfaces[i].checkBounds(this);
TypeParameter[] typeParameters = referenceContext.typeParameters;
if (typeParameters != null)
for (int i = 0, paramLength = typeParameters.length; i < paramLength; i++)
typeParameters[i].checkBounds(this);
ReferenceBinding[] memberTypes = referenceContext.binding.memberTypes;
if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES)
for (int i = 0, size = memberTypes.length; i < size; i++)
((SourceTypeBinding) memberTypes[i]).scope.checkParameterizedTypeBounds();
}
private void connectMemberTypes() {
SourceTypeBinding sourceType = referenceContext.binding;
ReferenceBinding[] memberTypes = sourceType.memberTypes;
if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES) {
for (int i = 0, size = memberTypes.length; i < size; i++)
((SourceTypeBinding) memberTypes[i]).scope.connectTypeHierarchy();
}
}
/*
Our current belief based on available JCK tests is:
inherited member types are visible as a potential superclass.
inherited interfaces are not visible when defining a superinterface.
Error recovery story:
ensure the superclass is set to java.lang.Object if a problem is detected
resolving the superclass.
Answer false if an error was reported against the sourceType.
*/
private boolean connectSuperclass() {
SourceTypeBinding sourceType = referenceContext.binding;
if (sourceType.id == T_JavaLangObject) { // handle the case of redefining java.lang.Object up front
sourceType.superclass = null;
sourceType.superInterfaces = Binding.NO_SUPERINTERFACES;
if (!sourceType.isClass())
problemReporter().objectMustBeClass(sourceType);
if (referenceContext.superclass != null || (referenceContext.superInterfaces != null && referenceContext.superInterfaces.length > 0))
problemReporter().objectCannotHaveSuperTypes(sourceType);
return true; // do not propagate Object's hierarchy problems down to every subtype
}
if (referenceContext.superclass == null) {
if (sourceType.isEnum() && compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) // do not connect if source < 1.5 as enum already got flagged as syntax error
return connectEnumSuperclass();
sourceType.superclass = getJavaLangObject();
return !detectHierarchyCycle(sourceType, sourceType.superclass, null);
}
TypeReference superclassRef = referenceContext.superclass;
ReferenceBinding superclass = findSupertype(superclassRef);
if (superclass != null) { // is null if a cycle was detected cycle or a problem
if (!superclass.isClass()) {
problemReporter().superclassMustBeAClass(sourceType, superclassRef, superclass);
} else if (superclass.isFinal()) {
problemReporter().classExtendFinalClass(sourceType, superclassRef, superclass);
} else if ((superclass.tagBits & TagBits.HasDirectWildcard) != 0) {
problemReporter().superTypeCannotUseWildcard(sourceType, superclassRef, superclass);
} else if (superclass.erasure().id == T_JavaLangEnum) {
problemReporter().cannotExtendEnum(sourceType, superclassRef, superclass);
} else {
// only want to reach here when no errors are reported
sourceType.superclass = superclass;
return true;
}
}
sourceType.tagBits |= TagBits.HierarchyHasProblems;
sourceType.superclass = getJavaLangObject();
if ((sourceType.superclass.tagBits & TagBits.BeginHierarchyCheck) == 0)
detectHierarchyCycle(sourceType, sourceType.superclass, null);
return false; // reported some error against the source type
}
/**
* enum X (implicitly) extends Enum<X>
*/
private boolean connectEnumSuperclass() {
SourceTypeBinding sourceType = referenceContext.binding;
ReferenceBinding rootEnumType = getJavaLangEnum();
boolean foundCycle = detectHierarchyCycle(sourceType, rootEnumType, null);
// arity check for well-known Enum<E>
TypeVariableBinding[] refTypeVariables = rootEnumType.typeVariables();
if (refTypeVariables == Binding.NO_TYPE_VARIABLES) { // check generic
problemReporter().nonGenericTypeCannotBeParameterized(null, rootEnumType, new TypeBinding[]{ sourceType });
return false; // cannot reach here as AbortCompilation is thrown
} else if (1 != refTypeVariables.length) { // check arity
problemReporter().incorrectArityForParameterizedType(null, rootEnumType, new TypeBinding[]{ sourceType });
return false; // cannot reach here as AbortCompilation is thrown
}
// check argument type compatibility
ParameterizedTypeBinding superType = environment().createParameterizedType(rootEnumType, new TypeBinding[]{ environment().convertToRawType(sourceType) } , null);
sourceType.superclass = superType;
// bound check (in case of bogus definition of Enum type)
if (refTypeVariables[0].boundCheck(superType, sourceType) != TypeConstants.OK) {
problemReporter().typeMismatchError(rootEnumType, refTypeVariables[0], sourceType, null);
}
return !foundCycle;
}
/*
Our current belief based on available JCK 1.3 tests is:
inherited member types are visible as a potential superclass.
inherited interfaces are visible when defining a superinterface.
Error recovery story:
ensure the superinterfaces contain only valid visible interfaces.
Answer false if an error was reported against the sourceType.
*/
private boolean connectSuperInterfaces() {
SourceTypeBinding sourceType = referenceContext.binding;
sourceType.superInterfaces = Binding.NO_SUPERINTERFACES;
if (referenceContext.superInterfaces == null) {
if (sourceType.isAnnotationType() && compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) { // do not connect if source < 1.5 as annotation already got flagged as syntax error) {
ReferenceBinding annotationType = getJavaLangAnnotationAnnotation();
boolean foundCycle = detectHierarchyCycle(sourceType, annotationType, null);
sourceType.superInterfaces = new ReferenceBinding[] { annotationType };
return !foundCycle;
}
return true;
}
if (sourceType.id == T_JavaLangObject) // already handled the case of redefining java.lang.Object
return true;
boolean noProblems = true;
int length = referenceContext.superInterfaces.length;
ReferenceBinding[] interfaceBindings = new ReferenceBinding[length];
int count = 0;
nextInterface : for (int i = 0; i < length; i++) {
TypeReference superInterfaceRef = referenceContext.superInterfaces[i];
ReferenceBinding superInterface = findSupertype(superInterfaceRef);
if (superInterface == null) { // detected cycle
sourceType.tagBits |= TagBits.HierarchyHasProblems;
noProblems = false;
continue nextInterface;
}
superInterfaceRef.resolvedType = superInterface; // hold onto the problem type
// check for simple interface collisions
// Check for a duplicate interface once the name is resolved, otherwise we may be confused (ie : a.b.I and c.d.I)
for (int j = 0; j < i; j++) {
if (interfaceBindings[j] == superInterface) {
problemReporter().duplicateSuperinterface(sourceType, superInterfaceRef, superInterface);
continue nextInterface;
}
}
if (!superInterface.isInterface()) {
problemReporter().superinterfaceMustBeAnInterface(sourceType, superInterfaceRef, superInterface);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
noProblems = false;
continue nextInterface;
} else if (superInterface.isAnnotationType()){
problemReporter().annotationTypeUsedAsSuperinterface(sourceType, superInterfaceRef, superInterface);
}
if ((superInterface.tagBits & TagBits.HasDirectWildcard) != 0) {
problemReporter().superTypeCannotUseWildcard(sourceType, superInterfaceRef, superInterface);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
noProblems = false;
continue nextInterface;
}
// only want to reach here when no errors are reported
interfaceBindings[count++] = superInterface;
}
// hold onto all correctly resolved superinterfaces
if (count > 0) {
if (count != length)
System.arraycopy(interfaceBindings, 0, interfaceBindings = new ReferenceBinding[count], 0, count);
sourceType.superInterfaces = interfaceBindings;
}
return noProblems;
}
void connectTypeHierarchy() {
SourceTypeBinding sourceType = referenceContext.binding;
if ((sourceType.tagBits & TagBits.BeginHierarchyCheck) == 0) {
sourceType.tagBits |= TagBits.BeginHierarchyCheck;
boolean noProblems = connectSuperclass();
noProblems &= connectSuperInterfaces();
sourceType.tagBits |= TagBits.EndHierarchyCheck;
noProblems &= connectTypeVariables(referenceContext.typeParameters, false);
sourceType.tagBits |= TagBits.TypeVariablesAreConnected;
if (noProblems && sourceType.isHierarchyInconsistent())
problemReporter().hierarchyHasProblems(sourceType);
}
connectMemberTypes();
try {
checkForInheritedMemberTypes(sourceType);
} catch (AbortCompilation e) {
e.updateContext(referenceContext, referenceCompilationUnit().compilationResult);
throw e;
}
}
private void connectTypeHierarchyWithoutMembers() {
// must ensure the imports are resolved
if (parent instanceof CompilationUnitScope) {
if (((CompilationUnitScope) parent).imports == null)
((CompilationUnitScope) parent).checkAndSetImports();
} else if (parent instanceof ClassScope) {
// ensure that the enclosing type has already been checked
((ClassScope) parent).connectTypeHierarchyWithoutMembers();
}
// double check that the hierarchy search has not already begun...
SourceTypeBinding sourceType = referenceContext.binding;
if ((sourceType.tagBits & TagBits.BeginHierarchyCheck) != 0)
return;
sourceType.tagBits |= TagBits.BeginHierarchyCheck;
boolean noProblems = connectSuperclass();
noProblems &= connectSuperInterfaces();
sourceType.tagBits |= TagBits.EndHierarchyCheck;
noProblems &= connectTypeVariables(referenceContext.typeParameters, false);
sourceType.tagBits |= TagBits.TypeVariablesAreConnected;
if (noProblems && sourceType.isHierarchyInconsistent())
problemReporter().hierarchyHasProblems(sourceType);
}
public boolean detectHierarchyCycle(TypeBinding superType, TypeReference reference, TypeBinding[] argTypes) {
if (!(superType instanceof ReferenceBinding)) return false;
if (reference == this.superTypeReference) { // see findSuperType()
if (superType.isTypeVariable())
return false; // error case caught in resolveSuperType()
// abstract class X<K,V> implements java.util.Map<K,V>
// static abstract class M<K,V> implements Entry<K,V>
if (superType.isParameterizedType())
superType = ((ParameterizedTypeBinding) superType).type;
compilationUnitScope().recordSuperTypeReference(superType); // to record supertypes
return detectHierarchyCycle(referenceContext.binding, (ReferenceBinding) superType, reference);
}
if ((superType.tagBits & TagBits.BeginHierarchyCheck) == 0 && superType instanceof SourceTypeBinding)
// ensure if this is a source superclass that it has already been checked
((SourceTypeBinding) superType).scope.connectTypeHierarchyWithoutMembers();
return false;
}
// Answer whether a cycle was found between the sourceType & the superType
private boolean detectHierarchyCycle(SourceTypeBinding sourceType, ReferenceBinding superType, TypeReference reference) {
if (superType.isRawType())
superType = ((RawTypeBinding) superType).type;
// by this point the superType must be a binary or source type
if (sourceType == superType) {
problemReporter().hierarchyCircularity(sourceType, superType, reference);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
return true;
}
// No longer believe this code is necessary, since we changed supertype lookup to use TypeReference resolution
// if (superType.isMemberType()) {
// ReferenceBinding current = superType.enclosingType();
// do {
// if (current.isHierarchyBeingConnected()) {
// problemReporter().hierarchyCircularity(sourceType, current, reference);
// sourceType.tagBits |= TagBits.HierarchyHasProblems;
// current.tagBits |= TagBits.HierarchyHasProblems;
// return true;
// }
// } while ((current = current.enclosingType()) != null);
// }
if (superType.isBinaryBinding()) {
// force its superclass & superinterfaces to be found... 2 possibilities exist - the source type is included in the hierarchy of:
// - a binary type... this case MUST be caught & reported here
// - another source type... this case is reported against the other source type
boolean hasCycle = false;
ReferenceBinding parentType = superType.superclass();
if (parentType != null) {
if (sourceType == parentType) {
problemReporter().hierarchyCircularity(sourceType, superType, reference);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
superType.tagBits |= TagBits.HierarchyHasProblems;
return true;
}
if (parentType.isParameterizedType())
parentType = ((ParameterizedTypeBinding) parentType).type;
hasCycle |= detectHierarchyCycle(sourceType, parentType, reference);
if ((parentType.tagBits & TagBits.HierarchyHasProblems) != 0) {
sourceType.tagBits |= TagBits.HierarchyHasProblems;
parentType.tagBits |= TagBits.HierarchyHasProblems; // propagate down the hierarchy
}
}
ReferenceBinding[] itsInterfaces = superType.superInterfaces();
if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
for (int i = 0, length = itsInterfaces.length; i < length; i++) {
ReferenceBinding anInterface = itsInterfaces[i];
if (sourceType == anInterface) {
problemReporter().hierarchyCircularity(sourceType, superType, reference);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
superType.tagBits |= TagBits.HierarchyHasProblems;
return true;
}
if (anInterface.isParameterizedType())
anInterface = ((ParameterizedTypeBinding) anInterface).type;
hasCycle |= detectHierarchyCycle(sourceType, anInterface, reference);
if ((anInterface.tagBits & TagBits.HierarchyHasProblems) != 0) {
sourceType.tagBits |= TagBits.HierarchyHasProblems;
superType.tagBits |= TagBits.HierarchyHasProblems;
}
}
}
return hasCycle;
}
if (superType.isHierarchyBeingConnected()) {
org.eclipse.jdt.internal.compiler.ast.TypeReference ref = ((SourceTypeBinding) superType).scope.superTypeReference;
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=133071
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=121734
if (ref != null && (ref.resolvedType == null || ((ReferenceBinding) ref.resolvedType).isHierarchyBeingConnected())) {
problemReporter().hierarchyCircularity(sourceType, superType, reference);
sourceType.tagBits |= TagBits.HierarchyHasProblems;
superType.tagBits |= TagBits.HierarchyHasProblems;
return true;
}
}
if ((superType.tagBits & TagBits.BeginHierarchyCheck) == 0)
// ensure if this is a source superclass that it has already been checked
((SourceTypeBinding) superType).scope.connectTypeHierarchyWithoutMembers();
if ((superType.tagBits & TagBits.HierarchyHasProblems) != 0)
sourceType.tagBits |= TagBits.HierarchyHasProblems;
return false;
}
private ReferenceBinding findSupertype(TypeReference typeReference) {
try {
typeReference.aboutToResolve(this); // allows us to trap completion & selection nodes
compilationUnitScope().recordQualifiedReference(typeReference.getTypeName());
this.superTypeReference = typeReference;
ReferenceBinding superType = (ReferenceBinding) typeReference.resolveSuperType(this);
this.superTypeReference = null;
return superType;
} catch (AbortCompilation e) {
e.updateContext(typeReference, referenceCompilationUnit().compilationResult);
throw e;
}
}
/* Answer the problem reporter to use for raising new problems.
*
* Note that as a side-effect, this updates the current reference context
* (unit, type or method) in case the problem handler decides it is necessary
* to abort.
*/
public ProblemReporter problemReporter() {
MethodScope outerMethodScope;
if ((outerMethodScope = outerMostMethodScope()) == null) {
ProblemReporter problemReporter = referenceCompilationUnit().problemReporter;
problemReporter.referenceContext = referenceContext;
return problemReporter;
}
return outerMethodScope.problemReporter();
}
/* Answer the reference type of this scope.
* It is the nearest enclosing type of this scope.
*/
public TypeDeclaration referenceType() {
return referenceContext;
}
public String toString() {
if (referenceContext != null)
return "--- Class Scope ---\n\n" //$NON-NLS-1$
+ referenceContext.binding.toString();
return "--- Class Scope ---\n\n Binding not initialized" ; //$NON-NLS-1$
}
}
| [
"[email protected]"
] | |
b6f62cf1d89cc7c50631ec43fb81a3fe9e1bf660 | 516b00f0af7e8949e48b4bd3c17cd2151fd4dd56 | /src/BaiTap2/ThanhToanOnline.java | ab2a32aec7115dfd1e16e4012c5444272528fb40 | [] | no_license | letandat-59130276/LeTanDat_59130276_StrateryPattern | 4b633e79af352df98e2881e567e49d39d987a916 | 74112a79b247822399991a0d401e7a6963c69f2c | refs/heads/master | 2022-04-20T23:05:43.006452 | 2020-04-19T03:59:22 | 2020-04-19T03:59:22 | 255,846,080 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 495 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package BaiTap2;
/**
*
* @author Con Meo Cutee
*/
public class ThanhToanOnline implements IThanhToan{
@Override
public double thanhToan(int tienHang) {
if(tienHang < 1000000)
return 0.95*tienHang;
else
return 0.93*tienHang;
}
}
| [
"Con Meo Cutee@DESKTOP-024VCJP"
] | Con Meo Cutee@DESKTOP-024VCJP |
2062399a825ecbf03c777a3e2f787d29d7264317 | 7c2f0c60697b395c7b51a517d78f7c0066b549e0 | /src/main/java/cn/zhanhuarecao/rediscluster/config/RedissonEntity.java | f0482b1ff5c84433846154762260f6d1a2b3008e | [] | no_license | missaouib/redis-cluster-1 | 508c0ac8d6a9646128a27d124b71e93d27d7cb39 | 94f361a78a6ac8177d53cc004ee96835556ce0a9 | refs/heads/master | 2023-03-02T14:24:07.386321 | 2021-02-08T08:17:01 | 2021-02-08T08:17:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,416 | java | package cn.zhanhuarecao.rediscluster.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import java.util.List;
@ConfigurationProperties(prefix = "redisson")
@PropertySource(value = "classpath:application.yml")
@Configuration
public class RedissonEntity {
private List<String> nodeAddresses;
private int connectionMinimumIdleSize = 10;
private int idleConnectionTimeout = 10000;
private int pingTimeout = 1000;
private int connectTimeout = 10000;
private int timeout = 3000;
private int retryAttempts = 3;
private int retryInterval = 1500;
private int reconnectionTimeout = 3000;
private int failedAttempts = 3;
private String password;
private int subscriptionsPerConnection = 5;
private String clientName = null;
private int subscriptionConnectionMinimumIdleSize = 1;
private int subscriptionConnectionPoolSize = 50;
private int connectionPoolSize = 64;
private int database = 0;
private boolean dnsMonitoring = false;
private int dnsMonitoringInterval = 5000;
private int thread = 4; //当前处理核数量 * 2
private String codec;
public List<String> getNodeAddresses() {
return nodeAddresses;
}
public void setNodeAddresses(List<String> nodeAddresses) {
this.nodeAddresses = nodeAddresses;
}
public int getConnectionMinimumIdleSize() {
return connectionMinimumIdleSize;
}
public void setConnectionMinimumIdleSize(int connectionMinimumIdleSize) {
this.connectionMinimumIdleSize = connectionMinimumIdleSize;
}
public int getIdleConnectionTimeout() {
return idleConnectionTimeout;
}
public void setIdleConnectionTimeout(int idleConnectionTimeout) {
this.idleConnectionTimeout = idleConnectionTimeout;
}
public int getPingTimeout() {
return pingTimeout;
}
public void setPingTimeout(int pingTimeout) {
this.pingTimeout = pingTimeout;
}
public int getConnectTimeout() {
return connectTimeout;
}
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public int getRetryAttempts() {
return retryAttempts;
}
public void setRetryAttempts(int retryAttempts) {
this.retryAttempts = retryAttempts;
}
public int getRetryInterval() {
return retryInterval;
}
public void setRetryInterval(int retryInterval) {
this.retryInterval = retryInterval;
}
public int getReconnectionTimeout() {
return reconnectionTimeout;
}
public void setReconnectionTimeout(int reconnectionTimeout) {
this.reconnectionTimeout = reconnectionTimeout;
}
public int getFailedAttempts() {
return failedAttempts;
}
public void setFailedAttempts(int failedAttempts) {
this.failedAttempts = failedAttempts;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getSubscriptionsPerConnection() {
return subscriptionsPerConnection;
}
public void setSubscriptionsPerConnection(int subscriptionsPerConnection) {
this.subscriptionsPerConnection = subscriptionsPerConnection;
}
public String getClientName() {
return clientName;
}
public void setClientName(String clientName) {
this.clientName = clientName;
}
public int getSubscriptionConnectionMinimumIdleSize() {
return subscriptionConnectionMinimumIdleSize;
}
public void setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize) {
this.subscriptionConnectionMinimumIdleSize = subscriptionConnectionMinimumIdleSize;
}
public int getSubscriptionConnectionPoolSize() {
return subscriptionConnectionPoolSize;
}
public void setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize) {
this.subscriptionConnectionPoolSize = subscriptionConnectionPoolSize;
}
public int getConnectionPoolSize() {
return connectionPoolSize;
}
public void setConnectionPoolSize(int connectionPoolSize) {
this.connectionPoolSize = connectionPoolSize;
}
public int getDatabase() {
return database;
}
public void setDatabase(int database) {
this.database = database;
}
public boolean isDnsMonitoring() {
return dnsMonitoring;
}
public void setDnsMonitoring(boolean dnsMonitoring) {
this.dnsMonitoring = dnsMonitoring;
}
public int getDnsMonitoringInterval() {
return dnsMonitoringInterval;
}
public void setDnsMonitoringInterval(int dnsMonitoringInterval) {
this.dnsMonitoringInterval = dnsMonitoringInterval;
}
public int getThread() {
return thread;
}
public void setThread(int thread) {
this.thread = thread;
}
public String getCodec() {
return codec;
}
public void setCodec(String codec) {
this.codec = codec;
}
}
| [
"[email protected]"
] | |
e881eeb3ebc6ceb36a0a70d663cacd528d90f64c | 67c89388e84c4e28d1559ee6665304708e5bf0b2 | /protocols/raft/src/main/java/io/atomix/protocols/raft/proxy/impl/RaftProxyManager.java | 2229f7f169695101fd642b1e3b35eb1a59393112 | [
"Apache-2.0"
] | permissive | maniacs-ops/atomix | f66e4eca65466fdda7dee9aec08b3a1cb51724dc | c28f884754f26edfec3677849e864eb3311738e7 | refs/heads/master | 2021-01-02T08:55:42.350924 | 2017-07-28T23:48:05 | 2017-07-28T23:48:05 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 15,165 | java | /*
* Copyright 2017-present Open Networking Laboratory
*
* 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 io.atomix.protocols.raft.proxy.impl;
import com.google.common.collect.Sets;
import com.google.common.primitives.Longs;
import io.atomix.protocols.raft.RaftClient;
import io.atomix.protocols.raft.RaftException;
import io.atomix.protocols.raft.ReadConsistency;
import io.atomix.protocols.raft.cluster.MemberId;
import io.atomix.protocols.raft.protocol.CloseSessionRequest;
import io.atomix.protocols.raft.protocol.KeepAliveRequest;
import io.atomix.protocols.raft.protocol.OpenSessionRequest;
import io.atomix.protocols.raft.protocol.RaftClientProtocol;
import io.atomix.protocols.raft.protocol.RaftResponse;
import io.atomix.protocols.raft.proxy.CommunicationStrategy;
import io.atomix.protocols.raft.proxy.RaftProxy;
import io.atomix.protocols.raft.proxy.RaftProxyClient;
import io.atomix.protocols.raft.service.ServiceType;
import io.atomix.protocols.raft.session.SessionId;
import io.atomix.utils.concurrent.Futures;
import io.atomix.utils.concurrent.ThreadContext;
import io.atomix.utils.concurrent.ThreadPoolContext;
import io.atomix.utils.logging.ContextualLoggerFactory;
import io.atomix.utils.logging.LoggerContext;
import org.slf4j.Logger;
import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import static com.google.common.base.MoreObjects.toStringHelper;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Client session manager.
*/
public class RaftProxyManager {
private final Logger log;
private final String clientId;
private final MemberId memberId;
private final RaftClientProtocol protocol;
private final RaftProxyConnection connection;
private final ScheduledExecutorService threadPoolExecutor;
private final MemberSelectorManager selectorManager;
private final Map<Long, RaftProxyState> sessions = new ConcurrentHashMap<>();
private final Map<Long, ScheduledFuture<?>> keepAliveFutures = new ConcurrentHashMap<>();
private final AtomicBoolean open = new AtomicBoolean();
public RaftProxyManager(String clientId, MemberId memberId, RaftClientProtocol protocol, MemberSelectorManager selectorManager, ScheduledExecutorService threadPoolExecutor) {
this.clientId = checkNotNull(clientId, "clientId cannot be null");
this.memberId = checkNotNull(memberId, "memberId cannot be null");
this.protocol = checkNotNull(protocol, "protocol cannot be null");
this.selectorManager = checkNotNull(selectorManager, "selectorManager cannot be null");
this.log = ContextualLoggerFactory.getLogger(getClass(), LoggerContext.builder(RaftClient.class)
.addValue(clientId)
.build());
this.connection = new RaftProxyConnection(
protocol,
selectorManager.createSelector(CommunicationStrategy.ANY),
new ThreadPoolContext(threadPoolExecutor),
LoggerContext.builder(RaftClient.class)
.addValue(clientId)
.build());
this.threadPoolExecutor = checkNotNull(threadPoolExecutor, "threadPoolExecutor cannot be null");
}
/**
* Resets the session manager's cluster information.
*/
public void resetConnections() {
selectorManager.resetAll();
}
/**
* Resets the session manager's cluster information.
*
* @param leader The leader address.
* @param servers The collection of servers.
*/
public void resetConnections(MemberId leader, Collection<MemberId> servers) {
selectorManager.resetAll(leader, servers);
}
/**
* Opens the session manager.
*
* @return A completable future to be called once the session manager is opened.
*/
public CompletableFuture<Void> open() {
open.set(true);
return CompletableFuture.completedFuture(null);
}
/**
* Opens a new session.
*
* @param serviceName The session name.
* @param serviceType The session type.
* @param communicationStrategy The strategy with which to communicate with servers.
* @param timeout The session timeout.
* @return A completable future to be completed once the session has been opened.
*/
public CompletableFuture<RaftProxyClient> openSession(
String serviceName,
ServiceType serviceType,
ReadConsistency readConsistency,
CommunicationStrategy communicationStrategy,
Duration timeout) {
checkNotNull(serviceName, "serviceName cannot be null");
checkNotNull(serviceType, "serviceType cannot be null");
checkNotNull(communicationStrategy, "communicationStrategy cannot be null");
checkNotNull(timeout, "timeout cannot be null");
log.debug("Opening session; name: {}, type: {}", serviceName, serviceType);
OpenSessionRequest request = OpenSessionRequest.newBuilder()
.withMemberId(memberId)
.withServiceName(serviceName)
.withServiceType(serviceType)
.withReadConsistency(readConsistency)
.withTimeout(timeout.toMillis())
.build();
CompletableFuture<RaftProxyClient> future = new CompletableFuture<>();
ThreadContext proxyContext = new ThreadPoolContext(threadPoolExecutor);
connection.openSession(request).whenCompleteAsync((response, error) -> {
if (error == null) {
if (response.status() == RaftResponse.Status.OK) {
// Create and store the proxy state.
RaftProxyState state = new RaftProxyState(
clientId,
SessionId.from(response.session()),
serviceName,
serviceType,
response.timeout());
sessions.put(state.getSessionId().id(), state);
state.addStateChangeListener(s -> {
if (s == RaftProxy.State.CLOSED) {
sessions.remove(state.getSessionId().id());
}
});
// Ensure the proxy session info is reset and the session is kept alive.
keepAliveSessions(state.getSessionTimeout());
// Create the proxy client and complete the future.
RaftProxyClient client = new DiscreteRaftProxyClient(
state,
protocol,
selectorManager,
this,
communicationStrategy,
proxyContext);
future.complete(client);
} else {
future.completeExceptionally(new RaftException.Unavailable(response.error().message()));
}
} else {
future.completeExceptionally(new RaftException.Unavailable(error.getMessage()));
}
}, proxyContext);
return future;
}
/**
* Closes a session.
*
* @param sessionId The session identifier.
* @return A completable future to be completed once the session is closed.
*/
public CompletableFuture<Void> closeSession(SessionId sessionId) {
RaftProxyState state = sessions.get(sessionId.id());
if (state == null) {
return Futures.exceptionalFuture(new RaftException.UnknownSession("Unknown session: " + sessionId));
}
log.info("Closing session {}", sessionId);
CloseSessionRequest request = CloseSessionRequest.newBuilder()
.withSession(sessionId.id())
.build();
CompletableFuture<Void> future = new CompletableFuture<>();
connection.closeSession(request).whenComplete((response, error) -> {
if (error == null) {
if (response.status() == RaftResponse.Status.OK) {
sessions.remove(sessionId.id());
future.complete(null);
} else {
future.completeExceptionally(response.error().createException());
}
} else {
future.completeExceptionally(error);
}
});
return future;
}
/**
* Resets indexes for the given session.
*
* @param sessionId The session for which to reset indexes.
* @return A completable future to be completed once the session's indexes have been reset.
*/
CompletableFuture<Void> resetIndexes(SessionId sessionId) {
RaftProxyState sessionState = sessions.get(sessionId.id());
if (sessionState == null) {
return Futures.exceptionalFuture(new IllegalArgumentException("Unknown session: " + sessionId));
}
CompletableFuture<Void> future = new CompletableFuture<>();
KeepAliveRequest request = KeepAliveRequest.newBuilder()
.withSessionIds(new long[]{sessionId.id()})
.withCommandSequences(new long[]{sessionState.getCommandResponse()})
.withEventIndexes(new long[]{sessionState.getEventIndex()})
.build();
connection.keepAlive(request).whenComplete((response, error) -> {
if (error == null) {
if (response.status() == RaftResponse.Status.OK) {
future.complete(null);
} else {
future.completeExceptionally(response.error().createException());
}
} else {
future.completeExceptionally(error);
}
});
return future;
}
/**
* Sends a keep-alive request to the cluster.
*/
private void keepAliveSessions(long timeout) {
keepAliveSessions(timeout, true);
}
/**
* Sends a keep-alive request to the cluster.
*/
private synchronized void keepAliveSessions(long timeout, boolean retryOnFailure) {
// Filter the list of sessions by timeout.
List<RaftProxyState> needKeepAlive = sessions.values()
.stream()
.filter(session -> session.getSessionTimeout() == timeout)
.collect(Collectors.toList());
// If no sessions need keep-alives to be sent, skip and reschedule the keep-alive.
if (needKeepAlive.isEmpty()) {
return;
}
// Allocate session IDs, command response sequence numbers, and event index arrays.
long[] sessionIds = new long[needKeepAlive.size()];
long[] commandResponses = new long[needKeepAlive.size()];
long[] eventIndexes = new long[needKeepAlive.size()];
// For each session that needs to be kept alive, populate batch request arrays.
int i = 0;
for (RaftProxyState sessionState : needKeepAlive) {
sessionIds[i] = sessionState.getSessionId().id();
commandResponses[i] = sessionState.getCommandResponse();
eventIndexes[i] = sessionState.getEventIndex();
i++;
}
log.debug("Keeping {} sessions alive", sessionIds.length);
KeepAliveRequest request = KeepAliveRequest.newBuilder()
.withSessionIds(sessionIds)
.withCommandSequences(commandResponses)
.withEventIndexes(eventIndexes)
.build();
long startTime = System.currentTimeMillis();
connection.keepAlive(request).whenComplete((response, error) -> {
if (open.get()) {
long delta = System.currentTimeMillis() - startTime;
if (error == null) {
// If the request was successful, update the address selector and schedule the next keep-alive.
if (response.status() == RaftResponse.Status.OK) {
selectorManager.resetAll(response.leader(), response.members());
// Iterate through sessions and close sessions that weren't kept alive by the request (have already been closed).
Set<Long> keptAliveSessions = Sets.newHashSet(Longs.asList(response.sessionIds()));
for (RaftProxyState session : needKeepAlive) {
if (keptAliveSessions.contains(session.getSessionId().id())) {
session.setState(RaftProxy.State.CONNECTED);
} else {
session.setState(RaftProxy.State.CLOSED);
}
}
scheduleKeepAlive(timeout, delta);
}
// If a leader is still set in the address selector, unset the leader and attempt to send another keep-alive.
// This will ensure that the address selector selects all servers without filtering on the leader.
else if (retryOnFailure && connection.leader() != null) {
selectorManager.resetAll(null, connection.servers());
keepAliveSessions(timeout, false);
}
// If no leader was set, set the session state to unstable and schedule another keep-alive.
else {
needKeepAlive.forEach(s -> s.setState(RaftProxy.State.SUSPENDED));
selectorManager.resetAll();
scheduleKeepAlive(timeout, delta);
}
}
// If a leader is still set in the address selector, unset the leader and attempt to send another keep-alive.
// This will ensure that the address selector selects all servers without filtering on the leader.
else if (retryOnFailure && connection.leader() != null) {
selectorManager.resetAll(null, connection.servers());
keepAliveSessions(timeout, false);
}
// If no leader was set, set the session state to unstable and schedule another keep-alive.
else {
needKeepAlive.forEach(s -> s.setState(RaftProxy.State.SUSPENDED));
selectorManager.resetAll();
scheduleKeepAlive(timeout, delta);
}
}
});
}
/**
* Schedules a keep-alive request.
*/
private synchronized void scheduleKeepAlive(long timeout, long delta) {
ScheduledFuture<?> keepAliveFuture = keepAliveFutures.remove(timeout);
if (keepAliveFuture != null) {
keepAliveFuture.cancel(false);
}
// Schedule the keep alive for 3/4 the timeout minus the delta from the last keep-alive request.
keepAliveFutures.put(timeout, threadPoolExecutor.schedule(() -> {
if (open.get()) {
keepAliveSessions(timeout);
}
}, Math.max(Math.max((long)(timeout * .75) - delta, timeout - 2500 - delta), 0), TimeUnit.MILLISECONDS));
}
/**
* Closes the session manager.
*
* @return A completable future to be completed once the session manager is closed.
*/
public CompletableFuture<Void> close() {
if (open.compareAndSet(true, false)) {
CompletableFuture<Void> future = new CompletableFuture<>();
threadPoolExecutor.execute(() -> {
for (ScheduledFuture<?> keepAliveFuture : keepAliveFutures.values()) {
keepAliveFuture.cancel(false);
}
future.complete(null);
});
return future;
}
return CompletableFuture.completedFuture(null);
}
@Override
public String toString() {
return toStringHelper(this)
.add("client", clientId)
.toString();
}
}
| [
"[email protected]"
] | |
ca2745587e0028e3d21062da5f8e2f05ca8568dc | 401c228cf3672c8754330711af7a7e5128f1cf19 | /kie-wb-common-stunner/kie-wb-common-stunner-sets/kie-wb-common-stunner-case-mgmt/kie-wb-common-stunner-case-mgmt-client/src/main/java/org/kie/workbench/common/stunner/cm/client/command/util/CaseManagementCommandUtil.java | 4b40c7cb38f659f7f5af660f9d66f4e30ebdc3ef | [
"Apache-2.0"
] | permissive | gitgabrio/kie-wb-common | f2fb145536a2c5bd60ddbaf1cb41dec5e93912ec | 57ffa0afc6819d784e60bd675bbdee5d0660ad1b | refs/heads/master | 2020-03-21T08:00:52.572728 | 2019-05-13T13:03:14 | 2019-05-13T13:03:14 | 138,314,007 | 0 | 0 | Apache-2.0 | 2019-09-27T12:27:30 | 2018-06-22T14:46:16 | Java | UTF-8 | Java | false | false | 1,441 | java | /*
* Copyright 2019 Red Hat, Inc. and/or its affiliates.
*
* 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.kie.workbench.common.stunner.cm.client.command.util;
import java.util.List;
import org.kie.workbench.common.stunner.core.graph.Edge;
import org.kie.workbench.common.stunner.core.graph.Node;
public class CaseManagementCommandUtil {
@SuppressWarnings("unchecked")
public static int getChildIndex(final Node parent,
final Node child) {
if (parent != null && child != null) {
List<Edge> outEdges = parent.getOutEdges();
if (null != outEdges && !outEdges.isEmpty()) {
for (int i = 0, n = outEdges.size(); i < n; i++) {
if (child.equals(outEdges.get(i).getTargetNode())) {
return i;
}
}
}
}
return -1;
}
}
| [
"[email protected]"
] | |
7961a4f3bae1366caa6b08d3a5df8212baca061b | 85b098fb578d9988c830f1ca6c7b6fceec96054a | /Info8000/src/br/com/nfe/comunicador/XMotivo.java | 5ab24a6f051663fb5fbe282134ef4484354948ea | [] | no_license | Blasterprateado/info8000 | 35c728eda8d23f9fb6ea4493bcbca0cbb0753170 | 181adc214e253ce6075a8a2be79e104637b39a78 | refs/heads/master | 2021-01-18T17:48:50.135101 | 2016-09-28T05:39:33 | 2016-09-28T05:39:33 | 69,123,172 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,673 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package br.com.nfe.comunicador;
/**
*
* @author Edson
*/
public class XMotivo {
private String Versao;
private String TpAmb;
private String VerAplic;
private String CStat;
private String XMotivo;
private String CUF;
private String DhRecbto;
public XMotivo(String re) {
setCamposXMotivo(re);
}
public XMotivo(XMotivo re) {
setCamposXMotivo(re);
}
public String getVersao() {
return Versao;
}
public void setVersao(String Versao) {
this.Versao = Versao;
}
public String getTpAmb() {
return TpAmb;
}
public void setTpAmb(String TpAmb) {
this.TpAmb = TpAmb;
}
public String getVerAplic() {
return VerAplic;
}
public void setVerAplic(String VerAplic) {
this.VerAplic = VerAplic;
}
public String getCStat() {
return CStat;
}
public void setCStat(String CStat) {
this.CStat = CStat;
}
public String getXMotivo() {
return XMotivo;
}
public void setXMotivo(String XMotivo) {
this.XMotivo = XMotivo;
}
public String getCUF() {
return CUF;
}
public void setCUF(String CUF) {
this.CUF = CUF;
}
public String getDhRecbto() {
return DhRecbto;
}
public void setDhRecbto(String DhRecbto) {
this.DhRecbto = DhRecbto;
}
private void setCamposXMotivo(XMotivo xMotivo) {
this.setCStat(xMotivo.getCStat());
this.setCUF(xMotivo.getCUF());
this.setDhRecbto(xMotivo.getDhRecbto());
this.setTpAmb(xMotivo.getTpAmb());
this.setVerAplic(xMotivo.getVerAplic());
this.setVersao(xMotivo.getVersao());
this.setXMotivo(xMotivo.getXMotivo());
}
private void setCamposXMotivo(String s) {
this.setCStat(TextUtils.lerTagIni("CStat", s));
this.setCUF(TextUtils.lerTagIni("CUF", s));
this.setDhRecbto(TextUtils.lerTagIni("DhRecbto", s));
this.setTpAmb(TextUtils.lerTagIni("TpAmb", s));
this.setVerAplic(TextUtils.lerTagIni("VerAplic", s));
this.setVersao(TextUtils.lerTagIni("Versao", s));
this.setXMotivo(TextUtils.lerTagIni("XMotivo", s));
}
@Override
public String toString() {
return "XMotivo{" + "Versao=" + Versao + ", TpAmb=" + TpAmb + ", VerAplic=" + VerAplic + ", CStat=" + CStat + ", XMotivo=" + XMotivo + ", CUF=" + CUF + ", DhRecbto=" + DhRecbto + '}';
}
}
| [
"[email protected]"
] | |
ecdc3d2a215a3fd8b5dcb0dbb55709f61c14b753 | dc79d4747f95827dad5519554a77bc597de05cc5 | /app/src/main/java/com/tao/xiaoyuanyuan/view/colorpicker/builder/PaintBuilder.java | 90b2a86e81a44eb110765dc4ff35a47534c953c3 | [] | no_license | lt594963425/xiaoyuanyuan2 | 46247076caff88ff2fc18367a0a335c6dc727ea6 | 108b8cfc0c6f50262d3c436e5c77730e00f76397 | refs/heads/master | 2021-07-22T00:32:38.875787 | 2020-07-30T10:01:04 | 2020-07-30T10:01:04 | 202,462,807 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,645 | java | package com.tao.xiaoyuanyuan.view.colorpicker.builder;
import android.graphics.Bitmap;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Shader;
/**
* @author vondear
* @date 2018/6/11 11:36:40 整合修改
*/
public class PaintBuilder {
public static PaintHolder newPaint() {
return new PaintHolder();
}
public static Shader createAlphaPatternShader(int size) {
size /= 2;
size = Math.max(8, size * 2);
return new BitmapShader(createAlphaBackgroundPattern(size), Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
}
private static Bitmap createAlphaBackgroundPattern(int size) {
Paint alphaPatternPaint = PaintBuilder.newPaint().build();
Bitmap bm = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
Canvas c = new Canvas(bm);
int s = Math.round(size / 2f);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if ((i + j) % 2 == 0) {
alphaPatternPaint.setColor(0xffffffff);
} else {
alphaPatternPaint.setColor(0xffd0d0d0);
}
c.drawRect(i * s, j * s, (i + 1) * s, (j + 1) * s, alphaPatternPaint);
}
}
return bm;
}
public static class PaintHolder {
private Paint paint;
private PaintHolder() {
this.paint = new Paint(Paint.ANTI_ALIAS_FLAG);
}
public PaintHolder color(int color) {
this.paint.setColor(color);
return this;
}
public PaintHolder antiAlias(boolean flag) {
this.paint.setAntiAlias(flag);
return this;
}
public PaintHolder style(Paint.Style style) {
this.paint.setStyle(style);
return this;
}
public PaintHolder mode(PorterDuff.Mode mode) {
this.paint.setXfermode(new PorterDuffXfermode(mode));
return this;
}
public PaintHolder stroke(float width) {
this.paint.setStrokeWidth(width);
return this;
}
public PaintHolder xPerMode(PorterDuff.Mode mode) {
this.paint.setXfermode(new PorterDuffXfermode(mode));
return this;
}
public PaintHolder shader(Shader shader) {
this.paint.setShader(shader);
return this;
}
public Paint build() {
return this.paint;
}
}
}
| [
"[email protected]"
] | |
bb4be98a0b07336c30ad953435ff2107db152385 | ab2fd960a295be52786b8d9394a7fd63e379b340 | /common/message/src/main/java/org/thingsboard/server/common/msg/session/ex/ProcessingTimeoutException.java | 2bf7033d39f6af10e3f82288f9aa9de435080945 | [
"Apache-2.0"
] | permissive | ltcong1411/SmartDeviceFrameworkV2 | 654f7460baa00d8acbc483dddf46b62ce6657eea | 6f1bbbf3a2a15d5c0527e68feebea370967bce8a | refs/heads/master | 2020-04-22T02:46:44.240516 | 2019-02-25T08:19:43 | 2019-02-25T08:19:43 | 170,062,547 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 810 | java | /**
* Copyright © 2016-2019 The Thingsboard Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* 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.thingsboard.server.common.msg.session.ex;
public class ProcessingTimeoutException extends Exception {
private static final long serialVersionUID = 1L;
}
| [
"[email protected]"
] | |
e08b59e5a9931c1343be5a6749f69b47e43b5795 | 6c41774581737c295c21d2bcd5dac96b98de9a74 | /src/main/java/com/eb/server/controllers/v1/UserController.java | 56f7a95d14690836e50f53486976d49e78608c49 | [] | no_license | Rastikko/old-erudite-battles-server | d81c007781de13d18c95c7a274c029733b588cba | 33fb2e1b264bee706545a0b6bf0499d9061543d2 | refs/heads/master | 2021-03-19T14:53:42.824496 | 2018-08-28T15:33:25 | 2018-08-28T15:33:25 | 115,243,203 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,133 | java | package com.eb.server.controllers.v1;
import com.eb.server.api.v1.model.RequestLoginDTO;
import com.eb.server.api.v1.model.UserDTO;
import com.eb.server.services.UserService;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
@RestController
@CrossOrigin
@RequestMapping(UserController.BASE_URL)
public class UserController {
public static final String BASE_URL = "/api/v1/users";
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping("/{id}")
@ResponseStatus(HttpStatus.OK)
public UserDTO getUserById(@PathVariable Long id) {
return userService.findUserDTOById(id);
}
@PostMapping("/login")
@ResponseStatus(HttpStatus.OK)
public UserDTO login(@RequestBody RequestLoginDTO requestLoginDTO ) {
return userService.findUserDTOByName(requestLoginDTO.getName());
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public void createNewUser(@RequestBody UserDTO userDTO) {
userService.createNewUser(userDTO);
}
}
| [
"[email protected]"
] | |
a5f0d2bee7dc1687def1f59eeb82595117b98e80 | efca855f83be608cc5fcd5f9976b820f09f11243 | /consensus/qbft/src/integration-test/java/org/enterchain/enter/consensus/qbft/test/SpuriousBehaviourTest.java | df827f98b106cf9d6e7840bbadfaa7bbf5e9464c | [
"Apache-2.0"
] | permissive | enterpact/enterchain | 5438e127c851597cbd7e274526c3328155483e58 | d8b272fa6885e5d263066da01fff3be74a6357a0 | refs/heads/master | 2023-05-28T12:48:02.535365 | 2021-06-09T20:44:01 | 2021-06-09T20:44:01 | 375,483,000 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,337 | java | /*
* Copyright ConsenSys AG.
*
* 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.
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.enterchain.enter.consensus.qbft.test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.enterchain.enter.consensus.qbft.support.IntegrationTestHelpers.createSignedCommitPayload;
import org.enterchain.enter.consensus.common.bft.ConsensusRoundIdentifier;
import org.enterchain.enter.consensus.common.bft.inttest.NodeParams;
import org.enterchain.enter.consensus.qbft.messagedata.QbftV1;
import org.enterchain.enter.consensus.qbft.messagewrappers.Commit;
import org.enterchain.enter.consensus.qbft.messagewrappers.Prepare;
import org.enterchain.enter.consensus.qbft.payload.MessageFactory;
import org.enterchain.enter.consensus.qbft.support.RoundSpecificPeers;
import org.enterchain.enter.consensus.qbft.support.TestContext;
import org.enterchain.enter.consensus.qbft.support.TestContextBuilder;
import org.enterchain.enter.consensus.qbft.support.ValidatorPeer;
import org.enterchain.enter.crypto.NodeKey;
import org.enterchain.enter.crypto.NodeKeyUtils;
import org.enterchain.enter.crypto.SECPSignature;
import org.enterchain.enter.ethereum.core.Block;
import org.enterchain.enter.ethereum.core.Hash;
import org.enterchain.enter.ethereum.core.Util;
import org.enterchain.enter.ethereum.p2p.rlpx.wire.MessageData;
import org.enterchain.enter.ethereum.p2p.rlpx.wire.RawMessage;
import java.time.Clock;
import java.time.Instant;
import java.time.ZoneId;
import org.apache.tuweni.bytes.Bytes;
import org.junit.Before;
import org.junit.Test;
public class SpuriousBehaviourTest {
private final long blockTimeStamp = 100;
private final Clock fixedClock =
Clock.fixed(Instant.ofEpochSecond(blockTimeStamp), ZoneId.systemDefault());
// Test is configured such that a remote peer is responsible for proposing a block
private final int NETWORK_SIZE = 5;
// Configuration ensures remote peer will provide proposal for first block
private final TestContext context =
new TestContextBuilder()
.validatorCount(NETWORK_SIZE)
.indexOfFirstLocallyProposedBlock(0)
.clock(fixedClock)
.buildAndStart();
private final ConsensusRoundIdentifier roundId = new ConsensusRoundIdentifier(1, 0);
private final RoundSpecificPeers peers = context.roundSpecificPeers(roundId);
private final Block proposedBlock =
context.createBlockForProposalFromChainHead(30, peers.getProposer().getNodeAddress());
private Prepare expectedPrepare;
private Commit expectedCommit;
@Before
public void setup() {
expectedPrepare =
context.getLocalNodeMessageFactory().createPrepare(roundId, proposedBlock.getHash());
expectedCommit =
new Commit(
createSignedCommitPayload(
roundId, proposedBlock, context.getLocalNodeParams().getNodeKey()));
}
@Test
public void badlyFormedRlpDoesNotPreventOngoingBftOperation() {
final MessageData illegalCommitMsg = new RawMessage(QbftV1.PREPARE, Bytes.EMPTY);
peers.getNonProposing(0).injectMessage(illegalCommitMsg);
peers.getProposer().injectProposal(roundId, proposedBlock);
peers.verifyMessagesReceived(expectedPrepare);
}
@Test
public void messageWithIllegalMessageCodeAreDiscardedAndDoNotPreventOngoingBftOperation() {
final MessageData illegalCommitMsg = new RawMessage(QbftV1.MESSAGE_SPACE, Bytes.EMPTY);
peers.getNonProposing(0).injectMessage(illegalCommitMsg);
peers.getProposer().injectProposal(roundId, proposedBlock);
peers.verifyMessagesReceived(expectedPrepare);
}
@Test
public void nonValidatorsCannotTriggerResponses() {
final NodeKey nonValidatorNodeKey = NodeKeyUtils.generate();
final NodeParams nonValidatorParams =
new NodeParams(
Util.publicKeyToAddress(nonValidatorNodeKey.getPublicKey()), nonValidatorNodeKey);
final ValidatorPeer nonvalidator =
new ValidatorPeer(
nonValidatorParams,
new MessageFactory(nonValidatorParams.getNodeKey()),
context.getEventMultiplexer());
nonvalidator.injectProposal(new ConsensusRoundIdentifier(1, 0), proposedBlock);
peers.verifyNoMessagesReceived();
}
@Test
public void preparesWithMisMatchedDigestAreNotRespondedTo() {
peers.getProposer().injectProposal(roundId, proposedBlock);
peers.verifyMessagesReceived(expectedPrepare);
peers.prepareForNonProposing(roundId, Hash.ZERO);
peers.verifyNoMessagesReceived();
peers.prepareForNonProposing(roundId, proposedBlock.getHash());
peers.verifyMessagesReceived(expectedCommit);
peers.prepareForNonProposing(roundId, Hash.ZERO);
assertThat(context.getCurrentChainHeight()).isEqualTo(0);
peers.commitForNonProposing(roundId, proposedBlock);
assertThat(context.getCurrentChainHeight()).isEqualTo(1);
}
@Test
public void oneCommitSealIsIllegalPreventsImport() {
peers.getProposer().injectProposal(roundId, proposedBlock);
peers.verifyMessagesReceived(expectedPrepare);
peers.prepareForNonProposing(roundId, proposedBlock.getHash());
// for a network of 5, 4 seals are required (local + 3 remote)
peers.getNonProposing(0).injectCommit(roundId, proposedBlock);
peers.getNonProposing(1).injectCommit(roundId, proposedBlock);
// nonProposer-2 will generate an invalid seal
final ValidatorPeer badSealPeer = peers.getNonProposing(2);
final SECPSignature illegalSeal = badSealPeer.getnodeKey().sign(Hash.ZERO);
badSealPeer.injectCommit(roundId, proposedBlock.getHash(), illegalSeal);
assertThat(context.getCurrentChainHeight()).isEqualTo(0);
// Now inject the REAL commit message
badSealPeer.injectCommit(roundId, proposedBlock);
assertThat(context.getCurrentChainHeight()).isEqualTo(1);
}
}
| [
"[email protected]"
] | |
2244fba42d557ecc399186e31b03c81bb34dd65b | e7af7c0e95e20eb8a137f62748e0cda6683b050a | /AtividadeContinua_04/src/Ex_01_C_TAD_Fila_Prioridade_Heap/Interfaces/PriorityQueue.java | c6d459983572734343733f53824a62762ac31d41 | [] | no_license | G-Impacta/AtividadeContinua04-ED | 9dfa544f56667af83bbea05f005a48d7e97b8e2d | 9edcd9182d633808107842e71ea2c9333b4f1a24 | refs/heads/main | 2023-04-24T14:57:52.236111 | 2021-04-28T10:04:51 | 2021-04-28T10:04:51 | 362,414,889 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 549 | java | package Ex_01_C_TAD_Fila_Prioridade_Heap.Interfaces;
import Ex_01_C_TAD_Fila_Prioridade_Heap.Excecoes.EmptyPriorityQueueException;
import Ex_01_C_TAD_Fila_Prioridade_Heap.Excecoes.InvalidKeyException;
public interface PriorityQueue<KEY, VALUE> {
public int size();
public boolean isEmpty();
public Entry<KEY, VALUE> min() throws EmptyPriorityQueueException;
public Entry<KEY, VALUE> insert(KEY key, VALUE value) throws InvalidKeyException;
public Entry<KEY, VALUE> removeMin() throws EmptyPriorityQueueException;
}
| [
"[email protected]"
] | |
3aaec629e3edb096b1bb51b814d9a61340fc2409 | 0790c45dc122c8b6d988862818868dd617f2d9ef | /src/main/java/com/dtl/gemini/widget/MorePopWindow.java | 83344b658a319e84ef55011df918c48af8338c41 | [] | no_license | wanlihua/Androidgit | 07034ae50c13df0b85070208012ceb8081e86d75 | 2c0767940e341d0db0ec7ad2cf42c0dc912876d2 | refs/heads/master | 2022-12-21T07:36:15.374736 | 2020-09-24T09:00:49 | 2020-09-24T09:00:49 | 298,209,185 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,570 | java | package com.dtl.gemini.widget;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.drawable.ColorDrawable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.widget.PopupWindow;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.dtl.gemini.R;
/**
* 大图灵
* 2019/2/18
* 左上角弹窗
**/
public class MorePopWindow extends PopupWindow {
Context context;
public RelativeLayout rl1;
public RelativeLayout rl2;
public RelativeLayout rl3;
public RelativeLayout rl4;
public RelativeLayout rl5;
public TextView textView1;
public TextView textView2;
public TextView textView3;
public TextView textView4;
public TextView textView5;
@SuppressLint("InflateParams")
public MorePopWindow(Context context, Object tv1, Object tv2, Object tv3, Object tv4, Object tv5) {
this.context = context;
LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View content = inflater.inflate(R.layout.popupwindow_add, null);
// 设置SelectPicPopupWindow的View
this.setContentView(content);
// 设置SelectPicPopupWindow弹出窗体的宽
this.setWidth(LayoutParams.WRAP_CONTENT);
// 设置SelectPicPopupWindow弹出窗体的高
this.setHeight(LayoutParams.WRAP_CONTENT);
// 设置SelectPicPopupWindow弹出窗体可点击
this.setFocusable(true);
this.setOutsideTouchable(true);
// 刷新状态
this.update();
// 实例化一个ColorDrawable颜色为半透明
ColorDrawable dw = new ColorDrawable(0000000000);
// 点back键和其他地方使其消失,设置了这个才能触发OnDismisslistener ，设置其他控件变化等操作
this.setBackgroundDrawable(dw);
// 设置SelectPicPopupWindow弹出窗体动画效果
this.setAnimationStyle(R.style.AnimationPreview);
rl1 = (RelativeLayout) content.findViewById(R.id.rl1);
rl2 = (RelativeLayout) content.findViewById(R.id.rl2);
rl3 = (RelativeLayout) content.findViewById(R.id.rl3);
rl4 = (RelativeLayout) content.findViewById(R.id.rl4);
rl5 = (RelativeLayout) content.findViewById(R.id.rl5);
textView1 = (TextView) content.findViewById(R.id.tv1);
textView2 = (TextView) content.findViewById(R.id.tv2);
textView3 = (TextView) content.findViewById(R.id.tv3);
textView4 = (TextView) content.findViewById(R.id.tv4);
textView5 = (TextView) content.findViewById(R.id.tv5);
if (tv1 != null)
rl1.setVisibility(View.VISIBLE);
else
rl1.setVisibility(View.GONE);
if (tv2 != null)
rl2.setVisibility(View.VISIBLE);
else
rl2.setVisibility(View.GONE);
if (tv3 != null)
rl3.setVisibility(View.VISIBLE);
else
rl3.setVisibility(View.GONE);
if (tv4 != null)
rl4.setVisibility(View.VISIBLE);
else
rl4.setVisibility(View.GONE);
if (tv5 != null)
rl5.setVisibility(View.VISIBLE);
else
rl5.setVisibility(View.GONE);
textView1.setText(tv1 + "");
textView2.setText(tv2 + "");
textView3.setText(tv3 + "");
textView4.setText(tv4 + "");
textView5.setText(tv5 + "");
}
public void tv1Btn(View.OnClickListener clickListener) {
textView1.setOnClickListener(clickListener);
}
public void tv2Btn(View.OnClickListener clickListener) {
textView2.setOnClickListener(clickListener);
}
public void tv3Btn(View.OnClickListener clickListener) {
textView3.setOnClickListener(clickListener);
}
public void tv4Btn(View.OnClickListener clickListener) {
textView4.setOnClickListener(clickListener);
}
public void tv5Btn(View.OnClickListener clickListener) {
textView5.setOnClickListener(clickListener);
}
public void dismissDialog() {
if (this.isShowing())
MorePopWindow.this.dismiss();
else
return;
}
/**
* 显示popupWindow
*
* @param parent
*/
public void showPopupWindow(View parent) {
if (!this.isShowing()) {
// 以下拉方式显示popupwindow
this.showAsDropDown(parent, 0, 0);
} else {
this.dismiss();
}
}
}
| [
"[email protected]"
] | |
d31ff55f899122d883222e55a5271e499086bc2c | cba56340735b3347c3fae1b46b747668e5d027f8 | /src/tss/tpm/TPM2_NV_Certify_REQUEST.java | 7ffcb6796a2fabda02f59d9d8ec5595be389336f | [
"MIT"
] | permissive | kvnmlr/tpm2.0-playground | 7cadd974ff27c231cfc6165056bca5b97e9db1fa | 9b423b5ef8fc8e697b9276ff6bfcb118be45573f | refs/heads/master | 2021-07-04T22:05:18.745386 | 2017-09-25T20:32:21 | 2017-09-25T20:32:21 | 104,788,255 | 2 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,092 | java | package tss.tpm;
import tss.*;
// -----------This is an auto-generated file: do not edit
//>>>
/**
* The purpose of this command is to certify the contents of an NV Index or portion of an NV Index.
*/
public class TPM2_NV_Certify_REQUEST extends TpmStructure
{
/**
* The purpose of this command is to certify the contents of an NV Index or portion of an NV Index.
*
* @param _signHandle handle of the key used to sign the attestation structure Auth Index: 1 Auth Role: USER
* @param _authHandle handle indicating the source of the authorization value for the NV Index Auth Index: 2 Auth Role: USER
* @param _nvIndex Index for the area to be certified Auth Index: None
* @param _qualifyingData user-provided qualifying data
* @param _inScheme signing scheme to use if the scheme for signHandle is TPM_ALG_NULL (One of TPMS_SIG_SCHEME_RSASSA, TPMS_SIG_SCHEME_RSAPSS, TPMS_SIG_SCHEME_ECDSA, TPMS_SIG_SCHEME_ECDAA, TPMS_SIG_SCHEME_SM2, TPMS_SIG_SCHEME_ECSCHNORR, TPMS_SCHEME_HMAC, TPMS_SCHEME_HASH, TPMS_NULL_SIG_SCHEME)
* @param _size number of octets to certify
* @param _offset octet offset into the NV area This value shall be less than or equal to the size of the nvIndex data.
*/
public TPM2_NV_Certify_REQUEST(TPM_HANDLE _signHandle,TPM_HANDLE _authHandle,TPM_HANDLE _nvIndex,byte[] _qualifyingData,TPMU_SIG_SCHEME _inScheme,int _size,int _offset)
{
signHandle = _signHandle;
authHandle = _authHandle;
nvIndex = _nvIndex;
qualifyingData = _qualifyingData;
inScheme = _inScheme;
size = (short)_size;
offset = (short)_offset;
}
/**
* The purpose of this command is to certify the contents of an NV Index or portion of an NV Index.
*/
public TPM2_NV_Certify_REQUEST() {};
/**
* handle of the key used to sign the attestation structure Auth Index: 1 Auth Role: USER
*/
public TPM_HANDLE signHandle;
/**
* handle indicating the source of the authorization value for the NV Index Auth Index: 2 Auth Role: USER
*/
public TPM_HANDLE authHandle;
/**
* Index for the area to be certified Auth Index: None
*/
public TPM_HANDLE nvIndex;
/**
* size in octets of the buffer field; may be 0
*/
// private short qualifyingDataSize;
/**
* user-provided qualifying data
*/
public byte[] qualifyingData;
/**
* scheme selector
*/
// private TPM_ALG_ID inSchemeScheme;
/**
* signing scheme to use if the scheme for signHandle is TPM_ALG_NULL
*/
public TPMU_SIG_SCHEME inScheme;
/**
* number of octets to certify
*/
public short size;
/**
* octet offset into the NV area This value shall be less than or equal to the size of the nvIndex data.
*/
public short offset;
public int GetUnionSelector_inScheme()
{
if(inScheme instanceof TPMS_SIG_SCHEME_RSASSA){return 0x0014; }
if(inScheme instanceof TPMS_SIG_SCHEME_RSAPSS){return 0x0016; }
if(inScheme instanceof TPMS_SIG_SCHEME_ECDSA){return 0x0018; }
if(inScheme instanceof TPMS_SIG_SCHEME_ECDAA){return 0x001A; }
if(inScheme instanceof TPMS_SIG_SCHEME_SM2){return 0x001B; }
if(inScheme instanceof TPMS_SIG_SCHEME_ECSCHNORR){return 0x001C; }
if(inScheme instanceof TPMS_SCHEME_HMAC){return 0x0005; }
if(inScheme instanceof TPMS_SCHEME_HASH){return 0x7FFF; }
if(inScheme instanceof TPMS_NULL_SIG_SCHEME){return 0x0010; }
throw new RuntimeException("Unrecognized type");
}
@Override
public void toTpm(OutByteBuf buf)
{
signHandle.toTpm(buf);
authHandle.toTpm(buf);
nvIndex.toTpm(buf);
buf.writeInt((qualifyingData!=null)?qualifyingData.length:0, 2);
buf.write(qualifyingData);
buf.writeInt(GetUnionSelector_inScheme(), 2);
((TpmMarshaller)inScheme).toTpm(buf);
buf.write(size);
buf.write(offset);
return;
}
@Override
public void initFromTpm(InByteBuf buf)
{
signHandle = TPM_HANDLE.fromTpm(buf);
authHandle = TPM_HANDLE.fromTpm(buf);
nvIndex = TPM_HANDLE.fromTpm(buf);
int _qualifyingDataSize = buf.readInt(2);
qualifyingData = new byte[_qualifyingDataSize];
buf.readArrayOfInts(qualifyingData, 1, _qualifyingDataSize);
int _inSchemeScheme = buf.readInt(2);
inScheme=null;
if(_inSchemeScheme==TPM_ALG_ID.RSASSA.toInt()) {inScheme = new TPMS_SIG_SCHEME_RSASSA();}
else if(_inSchemeScheme==TPM_ALG_ID.RSAPSS.toInt()) {inScheme = new TPMS_SIG_SCHEME_RSAPSS();}
else if(_inSchemeScheme==TPM_ALG_ID.ECDSA.toInt()) {inScheme = new TPMS_SIG_SCHEME_ECDSA();}
else if(_inSchemeScheme==TPM_ALG_ID.ECDAA.toInt()) {inScheme = new TPMS_SIG_SCHEME_ECDAA();}
// code generator workaround BUGBUG >> (probChild)else if(_inSchemeScheme==TPM_ALG_ID.SM2.toInt()) {inScheme = new TPMS_SIG_SCHEME_SM2();}
// code generator workaround BUGBUG >> (probChild)else if(_inSchemeScheme==TPM_ALG_ID.ECSCHNORR.toInt()) {inScheme = new TPMS_SIG_SCHEME_ECSCHNORR();}
else if(_inSchemeScheme==TPM_ALG_ID.HMAC.toInt()) {inScheme = new TPMS_SCHEME_HMAC();}
else if(_inSchemeScheme==TPM_ALG_ID.ANY.toInt()) {inScheme = new TPMS_SCHEME_HASH();}
else if(_inSchemeScheme==TPM_ALG_ID.NULL.toInt()) {inScheme = new TPMS_NULL_SIG_SCHEME();}
if(inScheme==null)throw new RuntimeException("Unexpected type selector");
inScheme.initFromTpm(buf);
size = (short) buf.readInt(2);
offset = (short) buf.readInt(2);
}
@Override
public byte[] toTpm()
{
OutByteBuf buf = new OutByteBuf();
toTpm(buf);
return buf.getBuf();
}
public static TPM2_NV_Certify_REQUEST fromTpm (byte[] x)
{
TPM2_NV_Certify_REQUEST ret = new TPM2_NV_Certify_REQUEST();
InByteBuf buf = new InByteBuf(x);
ret.initFromTpm(buf);
if (buf.bytesRemaining()!=0)
throw new AssertionError("bytes remaining in buffer after object was de-serialized");
return ret;
}
public static TPM2_NV_Certify_REQUEST fromTpm (InByteBuf buf)
{
TPM2_NV_Certify_REQUEST ret = new TPM2_NV_Certify_REQUEST();
ret.initFromTpm(buf);
return ret;
}
@Override
public String toString()
{
TpmStructurePrinter _p = new TpmStructurePrinter("TPM2_NV_Certify_REQUEST");
toStringInternal(_p, 1);
_p.endStruct();
return _p.toString();
}
@Override
public void toStringInternal(TpmStructurePrinter _p, int d)
{
_p.add(d, "TPM_HANDLE", "signHandle", signHandle);
_p.add(d, "TPM_HANDLE", "authHandle", authHandle);
_p.add(d, "TPM_HANDLE", "nvIndex", nvIndex);
_p.add(d, "byte", "qualifyingData", qualifyingData);
_p.add(d, "TPMU_SIG_SCHEME", "inScheme", inScheme);
_p.add(d, "ushort", "size", size);
_p.add(d, "ushort", "offset", offset);
};
};
//<<<
| [
"[email protected]"
] | |
045430535301fb48895423fc93a68ee4d30cf8de | 13db4a1d034aa9dc3b97ba5a4c758eb37ef254df | /opserv-sp-service-impl/src/main/java/com/cognizant/opserv/sp/service/internal/MetricIntService.java | a83cacfe16af5499c0504bb586209bb8c196c067 | [] | no_license | deepthikamaraj/javaCode | 3436c539c0abcaeb3fbec87ccd1b79b543dffbc6 | 7634d01d5553496c7f5549382651ae63f371f8cc | refs/heads/master | 2021-04-06T08:54:22.184740 | 2018-03-13T09:57:40 | 2018-03-13T09:57:40 | 125,029,394 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,341 | java | package com.cognizant.opserv.sp.service.internal;
import java.util.List;
import com.cognizant.opserv.sp.exception.MetricServiceException;
import com.cognizant.opserv.sp.model.auth.UserDetails;
import com.cognizant.opserv.sp.model.metric.RangeDetails;
/**
* ****************************************************************************.
*
* @class MetricIntService contains all the metric internal services
* @author Cognizant Technology Solutions
* @version OpServ 3.0
* @since 30/03/2016
* ***************************************************************************
*/
public interface MetricIntService {
/**
* Gets the range details for salespos metrics.
*
* @param mtrId the mtr id
* @param userDetails the user details
* @return the range details by metric
* @throws MetricServiceException the metric service exception
*/
List<RangeDetails> getRangeDetailsForSalesPosMetrics(long mtrId, UserDetails userDetails) throws MetricServiceException;
/**
* Gets the range details for geo metrics.
*
* @param mtrId the mtr id
* @param userDetails the user details
* @return the range details for geo metrics
* @throws MetricServiceException the metric service exception
*/
public List<RangeDetails> getRangeDetailsForGeoMetrics(Long mtrId,UserDetails userDetails) throws MetricServiceException;
}
| [
"[email protected]"
] | |
f480c1ed940fb59916589b70b8498357d3697a24 | bf640d825debde2b8b3fd993b80d1f30c69db6af | /server/src/main/java/com/cezarykluczynski/stapi/server/comicStrip/reader/ComicStripRestReader.java | 560540ba046d5164cc382494645e1e14538fb65f | [
"MIT"
] | permissive | mastermind1981/stapi | 6b8395a18a0097312d33780f6cd5e203f20acf99 | 5e9251e0ca800c6b5d607a7977554675231d785c | refs/heads/master | 2021-01-20T12:49:17.620368 | 2017-05-05T17:18:53 | 2017-05-05T17:18:53 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,901 | java | package com.cezarykluczynski.stapi.server.comicStrip.reader;
import com.cezarykluczynski.stapi.client.v1.rest.model.ComicStripBaseResponse;
import com.cezarykluczynski.stapi.client.v1.rest.model.ComicStripFullResponse;
import com.cezarykluczynski.stapi.model.comicStrip.entity.ComicStrip;
import com.cezarykluczynski.stapi.server.comicStrip.dto.ComicStripRestBeanParams;
import com.cezarykluczynski.stapi.server.comicStrip.mapper.ComicStripBaseRestMapper;
import com.cezarykluczynski.stapi.server.comicStrip.mapper.ComicStripFullRestMapper;
import com.cezarykluczynski.stapi.server.comicStrip.query.ComicStripRestQuery;
import com.cezarykluczynski.stapi.server.common.mapper.PageMapper;
import com.cezarykluczynski.stapi.server.common.reader.BaseReader;
import com.cezarykluczynski.stapi.server.common.reader.FullReader;
import com.cezarykluczynski.stapi.server.common.validator.StaticValidator;
import com.google.common.collect.Iterables;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
import javax.inject.Inject;
@Service
public class ComicStripRestReader implements BaseReader<ComicStripRestBeanParams, ComicStripBaseResponse>,
FullReader<String, ComicStripFullResponse> {
private ComicStripRestQuery comicStripRestQuery;
private ComicStripBaseRestMapper comicStripBaseRestMapper;
private ComicStripFullRestMapper comicStripFullRestMapper;
private PageMapper pageMapper;
@Inject
public ComicStripRestReader(ComicStripRestQuery comicStripRestQuery, ComicStripBaseRestMapper comicStripBaseRestMapper,
ComicStripFullRestMapper comicStripFullRestMapper, PageMapper pageMapper) {
this.comicStripRestQuery = comicStripRestQuery;
this.comicStripBaseRestMapper = comicStripBaseRestMapper;
this.comicStripFullRestMapper = comicStripFullRestMapper;
this.pageMapper = pageMapper;
}
@Override
public ComicStripBaseResponse readBase(ComicStripRestBeanParams comicStripRestBeanParams) {
Page<ComicStrip> comicStripPage = comicStripRestQuery.query(comicStripRestBeanParams);
ComicStripBaseResponse comicStripResponse = new ComicStripBaseResponse();
comicStripResponse.setPage(pageMapper.fromPageToRestResponsePage(comicStripPage));
comicStripResponse.getComicStrips().addAll(comicStripBaseRestMapper.mapBase(comicStripPage.getContent()));
return comicStripResponse;
}
@Override
public ComicStripFullResponse readFull(String uid) {
StaticValidator.requireUid(uid);
ComicStripRestBeanParams comicStripRestBeanParams = new ComicStripRestBeanParams();
comicStripRestBeanParams.setUid(uid);
Page<ComicStrip> comicStripPage = comicStripRestQuery.query(comicStripRestBeanParams);
ComicStripFullResponse comicStripResponse = new ComicStripFullResponse();
comicStripResponse.setComicStrip(comicStripFullRestMapper.mapFull(Iterables.getOnlyElement(comicStripPage.getContent(), null)));
return comicStripResponse;
}
}
| [
"[email protected]"
] | |
54ff78c998a22162fab26d9e7e443193eb39e9be | f7fbc015359f7e2a7bae421918636b608ea4cef6 | /base/branches/odbcproto1/src/org/hsqldb/ParserBase.java | 80a76274d1c288bbdbf942996ab7cfcc9e56e431 | [] | no_license | svn2github/hsqldb | cdb363112cbdb9924c816811577586f0bf8aba90 | 52c703b4d54483899d834b1c23c1de7173558458 | refs/heads/master | 2023-09-03T10:33:34.963710 | 2019-01-18T23:07:40 | 2019-01-18T23:07:40 | 155,365,089 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 20,146 | java | /* Copyright (c) 2001-2009, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hsqldb;
import java.math.BigDecimal;
import org.hsqldb.HsqlNameManager.HsqlName;
import org.hsqldb.lib.ArrayUtil;
import org.hsqldb.lib.HsqlArrayList;
import org.hsqldb.lib.IntKeyIntValueHashMap;
import org.hsqldb.types.IntervalType;
import org.hsqldb.types.NumberType;
import org.hsqldb.types.TimeData;
import org.hsqldb.types.Type;
/**
* @author Fred Toussi (fredt@users dot sourceforge.net)
* @version 1.9.0
* @since 1.9.0
*/
public class ParserBase {
private Scanner scanner;
protected Token token;
//
protected boolean isRecording;
protected HsqlArrayList recordedStatement;
//
protected boolean isCheckOrTriggerCondition;
protected boolean isSchemaDefinition;
protected int parsePosition;
static final BigDecimal LONG_MAX_VALUE_INCREMENT =
BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(1));
/**
* Constructs a new BaseParser object with the given context.
*
* @param t the token source from which to parse commands
*/
ParserBase(Scanner t) {
scanner = t;
token = scanner.token;
}
public Scanner getScanner() {
return scanner;
}
public int getParsePosition() {
return parsePosition;
}
public void setParsePosition(int parsePosition) {
this.parsePosition = parsePosition;
}
/**
* Resets this parse context with the given SQL character sequence.
*
* Internal structures are reset as though a new parser were created
* with the given sql and the originally specified database and session
*
* @param sql a new SQL character sequence to replace the current one
*/
void reset(String sql) {
scanner.reset(sql);
//
parsePosition = 0;
isCheckOrTriggerCondition = false;
isSchemaDefinition = false;
isRecording = false;
recordedStatement = null;
}
int getPosition() {
return scanner.getTokenPosition();
}
void rewind(int position) throws HsqlException {
if (position == scanner.getTokenPosition()) {
return;
}
scanner.position(position);
if (isRecording) {
int i = recordedStatement.size() - 1;
for (; i >= 0; i--) {
Token token = (Token) recordedStatement.get(i);
if (token.position < position) {
break;
}
}
recordedStatement.setSize(i + 1);
}
read();
}
String getLastPart() {
return scanner.getPart(parsePosition, scanner.getTokenPosition());
}
String getLastPart(int position) {
return scanner.getPart(position, scanner.getTokenPosition());
}
String getLastPartAndCurrent(int position) {
return scanner.getPart(position, scanner.getPosition());
}
String getStatement(int startPosition,
short[] startTokens) throws HsqlException {
while (true) {
if (ArrayUtil.find(startTokens, token.tokenType) != -1) {
break;
}
read();
}
String sql = scanner.getPart(startPosition, scanner.getPosition());
return sql;
}
//
void startRecording() {
recordedStatement = new HsqlArrayList();
recordedStatement.add(token.duplicate());
isRecording = true;
}
void recordExpressionForToken(ExpressionColumn expression)
throws HsqlException {
if (isRecording) {
Token recordToken =
(Token) recordedStatement.get(recordedStatement.size() - 1);
recordToken.columnExpression = expression;
}
}
Token[] getRecordedStatement() {
isRecording = false;
recordedStatement.remove(recordedStatement.size() - 1);
Token[] tokens = new Token[recordedStatement.size()];
recordedStatement.toArray(tokens);
recordedStatement = null;
return tokens;
}
void read() throws HsqlException {
scanner.scanNext();
if (token.isMalformed) {
int errorCode = -1;
switch (token.tokenType) {
case Tokens.X_MALFORMED_BINARY_STRING :
errorCode = ErrorCode.X_42587;
break;
case Tokens.X_MALFORMED_BIT_STRING :
errorCode = ErrorCode.X_42588;
break;
case Tokens.X_MALFORMED_UNICODE_STRING :
errorCode = ErrorCode.X_42586;
break;
case Tokens.X_MALFORMED_STRING :
errorCode = ErrorCode.X_42584;
break;
case Tokens.X_UNKNOWN_TOKEN :
errorCode = ErrorCode.X_42582;
break;
case Tokens.X_MALFORMED_NUMERIC :
errorCode = ErrorCode.X_42585;
break;
case Tokens.X_MALFORMED_COMMENT :
errorCode = ErrorCode.X_42589;
break;
case Tokens.X_MALFORMED_IDENTIFIER :
errorCode = ErrorCode.X_42583;
break;
}
throw Error.error(errorCode);
}
if (isRecording) {
Token dup = token.duplicate();
dup.position = scanner.getTokenPosition();
recordedStatement.add(dup);
}
}
boolean isReservedKey() {
return scanner.token.isReservedIdentifier;
}
boolean isCoreReservedKey() {
return scanner.token.isCoreReservedIdentifier;
}
boolean isNonReservedIdentifier() {
return !scanner.token.isReservedIdentifier
&& (scanner.token.isUndelimitedIdentifier
|| scanner.token.isDelimitedIdentifier);
}
void checkIsNonReservedIdentifier() throws HsqlException {
if (!isNonReservedIdentifier()) {
throw unexpectedToken();
}
}
boolean isNonCoreReservedIdentifier() {
return !scanner.token.isCoreReservedIdentifier
&& (scanner.token.isUndelimitedIdentifier
|| scanner.token.isDelimitedIdentifier);
}
void checkIsNonCoreReservedIdentifier() throws HsqlException {
if (!isNonCoreReservedIdentifier()) {
throw unexpectedToken();
}
}
boolean isIdentifier() {
return scanner.token.isUndelimitedIdentifier
|| scanner.token.isDelimitedIdentifier;
}
void checkIsIdentifier() throws HsqlException {
if (!isIdentifier()) {
throw unexpectedToken();
}
}
boolean isDelimitedIdentifier() {
return scanner.token.isDelimitedIdentifier;
}
void checkIsDelimitedIdentifier() throws HsqlException {
if (token.tokenType != Tokens.X_DELIMITED_IDENTIFIER) {
throw Error.error(ErrorCode.X_42569);
}
}
void checkIsNotQuoted() throws HsqlException {
if (token.tokenType == Tokens.X_DELIMITED_IDENTIFIER) {
throw unexpectedToken();
}
}
void checkIsValue() throws HsqlException {
if (token.tokenType != Tokens.X_VALUE) {
throw unexpectedToken();
}
}
void checkIsValue(int dataTypeCode) throws HsqlException {
if (token.tokenType != Tokens.X_VALUE
|| token.dataType.typeCode != dataTypeCode) {
throw unexpectedToken();
}
}
void checkIsThis(int type) throws HsqlException {
if (token.tokenType != type) {
throw unexpectedToken();
}
}
boolean isUndelimitedSimpleName() {
return token.isUndelimitedIdentifier && token.namePrefix == null;
}
boolean isDelimitedSimpleName() {
return token.isDelimitedIdentifier && token.namePrefix == null;
}
boolean isSimpleName() {
return isNonReservedIdentifier() && token.namePrefix == null;
}
void checkIsSimpleName() throws HsqlException {
if (!isSimpleName()) {
throw unexpectedToken();
}
}
void readQuotedString() throws HsqlException {
if (token.dataType.typeCode != Types.SQL_CHAR) {
throw Error.error(ErrorCode.X_42565);
}
}
void readThis(int tokenId) throws HsqlException {
if (token.tokenType != tokenId) {
String required = Tokens.getKeyword(tokenId);
throw unexpectedTokenRequire(required);
}
read();
}
boolean readIfThis(int tokenId) throws HsqlException {
if (token.tokenType == tokenId) {
read();
return true;
}
return false;
}
int readInteger() throws HsqlException {
boolean minus = false;
if (token.tokenType == Tokens.MINUS) {
minus = true;
read();
}
checkIsValue();
if (minus && token.dataType.typeCode == Types.SQL_BIGINT
&& ((Number) token.tokenValue).longValue()
== -(long) Integer.MIN_VALUE) {
read();
return Integer.MIN_VALUE;
}
if (token.dataType.typeCode != Types.SQL_INTEGER) {
throw Error.error(ErrorCode.X_42565);
}
int val = ((Number) token.tokenValue).intValue();
if (minus) {
val = -val;
}
read();
return val;
}
long readBigint() throws HsqlException {
boolean minus = false;
if (token.tokenType == Tokens.MINUS) {
minus = true;
read();
}
checkIsValue();
if (minus && token.dataType.typeCode == Types.SQL_NUMERIC
&& LONG_MAX_VALUE_INCREMENT.equals(token.tokenValue)) {
read();
return Long.MIN_VALUE;
}
if (token.dataType.typeCode != Types.SQL_INTEGER
&& token.dataType.typeCode != Types.SQL_BIGINT) {
throw Error.error(ErrorCode.X_42565);
}
long val = ((Number) token.tokenValue).longValue();
if (minus) {
val = -val;
}
read();
return val;
}
Expression readDateTimeIntervalLiteral() throws HsqlException {
int pos = getPosition();
switch (token.tokenType) {
case Tokens.DATE : {
read();
if (token.tokenType != Tokens.X_VALUE
|| token.dataType.typeCode != Types.SQL_CHAR) {
break;
}
String s = token.tokenString;
read();
Object date = scanner.newDate(s);
return new ExpressionValue(date, Type.SQL_DATE);
}
case Tokens.TIME : {
read();
if (token.tokenType != Tokens.X_VALUE
|| token.dataType.typeCode != Types.SQL_CHAR) {
break;
}
String s = token.tokenString;
read();
TimeData value = scanner.newTime(s);
Type dataType = scanner.dateTimeType;
return new ExpressionValue(value, dataType);
}
case Tokens.TIMESTAMP : {
read();
if (token.tokenType != Tokens.X_VALUE
|| token.dataType.typeCode != Types.SQL_CHAR) {
break;
}
String s = token.tokenString;
read();
Object date = scanner.newTimestamp(s);
Type dataType = scanner.dateTimeType;
return new ExpressionValue(date, dataType);
}
case Tokens.INTERVAL : {
boolean minus = false;
read();
if (token.tokenType == Tokens.MINUS) {
read();
minus = true;
} else if (token.tokenType == Tokens.PLUS) {
read();
}
if (token.tokenType != Tokens.X_VALUE
|| token.dataType.typeCode != Types.SQL_CHAR) {
break;
}
String s = token.tokenString;
read();
IntervalType dataType = readIntervalType();
Object interval = scanner.newInterval(s, dataType);
dataType = (IntervalType) scanner.dateTimeType;
if (minus) {
interval = dataType.negate(interval);
}
return new ExpressionValue(interval, dataType);
}
default :
throw Error.runtimeError(ErrorCode.U_S0500, "Parser");
}
rewind(pos);
return null;
}
IntervalType readIntervalType() throws HsqlException {
int precision = -1;
int scale = -1;
int startToken;
int endToken;
startToken = endToken = token.tokenType;
read();
if (token.tokenType == Tokens.OPENBRACKET) {
read();
precision = readInteger();
if (precision <= 0) {
throw Error.error(ErrorCode.X_42592);
}
if (token.tokenType == Tokens.COMMA) {
if (startToken != Tokens.SECOND) {
throw unexpectedToken();
}
read();
scale = readInteger();
if (scale < 0) {
throw Error.error(ErrorCode.X_42592);
}
}
readThis(Tokens.CLOSEBRACKET);
}
if (token.tokenType == Tokens.TO) {
read();
endToken = token.tokenType;
read();
}
if (token.tokenType == Tokens.OPENBRACKET) {
if (endToken != Tokens.SECOND || endToken == startToken) {
throw unexpectedToken();
}
read();
scale = readInteger();
if (scale < 0) {
throw Error.error(ErrorCode.X_42592);
}
readThis(Tokens.CLOSEBRACKET);
}
int startIndex = ArrayUtil.find(Tokens.SQL_INTERVAL_FIELD_CODES,
startToken);
int endIndex = ArrayUtil.find(Tokens.SQL_INTERVAL_FIELD_CODES,
endToken);
return IntervalType.getIntervalType(startIndex, endIndex, precision,
scale);
}
static int getExpressionType(int tokenT) {
int type = expressionTypeMap.get(tokenT, -1);
if (type == -1) {
throw Error.runtimeError(ErrorCode.U_S0500, "Parser");
}
return type;
}
private static final IntKeyIntValueHashMap expressionTypeMap =
new IntKeyIntValueHashMap(37);
static {
// comparison
expressionTypeMap.put(Tokens.EQUALS, OpTypes.EQUAL);
expressionTypeMap.put(Tokens.GREATER, OpTypes.GREATER);
expressionTypeMap.put(Tokens.LESS, OpTypes.SMALLER);
expressionTypeMap.put(Tokens.GREATER_EQUALS, OpTypes.GREATER_EQUAL);
expressionTypeMap.put(Tokens.LESS_EQUALS, OpTypes.SMALLER_EQUAL);
expressionTypeMap.put(Tokens.NOT_EQUALS, OpTypes.NOT_EQUAL);
// aggregates
expressionTypeMap.put(Tokens.COUNT, OpTypes.COUNT);
expressionTypeMap.put(Tokens.MAX, OpTypes.MAX);
expressionTypeMap.put(Tokens.MIN, OpTypes.MIN);
expressionTypeMap.put(Tokens.SUM, OpTypes.SUM);
expressionTypeMap.put(Tokens.AVG, OpTypes.AVG);
expressionTypeMap.put(Tokens.EVERY, OpTypes.EVERY);
expressionTypeMap.put(Tokens.ANY, OpTypes.SOME);
expressionTypeMap.put(Tokens.SOME, OpTypes.SOME);
expressionTypeMap.put(Tokens.STDDEV_POP, OpTypes.STDDEV_POP);
expressionTypeMap.put(Tokens.STDDEV_SAMP, OpTypes.STDDEV_SAMP);
expressionTypeMap.put(Tokens.VAR_POP, OpTypes.VAR_POP);
expressionTypeMap.put(Tokens.VAR_SAMP, OpTypes.VAR_SAMP);
}
HsqlException unexpectedToken(String tokenS) {
return Error.error(ErrorCode.X_42581, tokenS);
}
HsqlException unexpectedTokenRequire(String required) {
if (token.tokenType == Tokens.X_ENDPARSE) {
return Error.error(ErrorCode.X_42590, ErrorCode.TOKEN_REQUIRED,
new Object[] {
"", required
});
}
String tokenS = token.namePrePrefix != null ? token.namePrePrefix
: token.namePrefix != null
? token.namePrefix
: token.tokenString;
return Error.error(ErrorCode.X_42581, ErrorCode.TOKEN_REQUIRED,
new Object[] {
tokenS, required
});
}
HsqlException unexpectedToken() {
if (token.tokenType == Tokens.X_ENDPARSE) {
return Error.error(ErrorCode.X_42590);
}
String tokenS = token.namePrePrefix != null ? token.namePrePrefix
: token.namePrefix != null
? token.namePrefix
: token.tokenString;
return Error.error(ErrorCode.X_42581, tokenS);
}
HsqlException tooManyIdentifiers() {
String tokenS = token.namePrePrefix != null ? token.namePrePrefix
: token.namePrefix != null
? token.namePrefix
: token.tokenString;
return Error.error(ErrorCode.X_42551, tokenS);
}
HsqlException unsupportedFeature() {
return Error.error(ErrorCode.X_0A501, token.tokenString);
}
HsqlException unsupportedFeature(String string) {
return Error.error(ErrorCode.X_0A501, string);
}
public Number convertToNumber(String s,
NumberType type) throws HsqlException {
return scanner.convertToNumber(s, type);
}
}
| [
"unsaved@7c7dc5f5-a22d-0410-a3af-b41755a11667"
] | unsaved@7c7dc5f5-a22d-0410-a3af-b41755a11667 |
99827a2281cfe0f3ea7a2f1228fb6497eec2a5de | 852006975748f9e2aec0e851730bd8e3af555f91 | /flink/src/main/java/com/logicalclocks/hsfs/constructor/Query.java | 0cfc9ede6031351abd9c36722a6e2da2bacac062 | [] | no_license | davitbzh/FlinkAggJob | 34c6531c6602128b1846c20ad4b37201fc7b9f75 | e5a4ce91adccdde3ed1f5f262c4133be5ad5d271 | refs/heads/master | 2023-08-17T00:59:45.862350 | 2021-09-16T23:12:46 | 2021-09-16T23:12:46 | 407,335,151 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 10,703 | java | /*
* Copyright (c) 2020 Logical Clocks AB
*
* 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 com.logicalclocks.hsfs.constructor;
import com.logicalclocks.hsfs.Feature;
import com.logicalclocks.hsfs.FeatureGroup;
import com.logicalclocks.hsfs.FeatureStoreException;
import com.logicalclocks.hsfs.OnDemandFeatureGroup;
import com.logicalclocks.hsfs.Storage;
import com.logicalclocks.hsfs.engine.Utils;
import com.logicalclocks.hsfs.metadata.FeatureGroupBase;
import com.logicalclocks.hsfs.metadata.QueryConstructorApi;
import com.logicalclocks.hsfs.metadata.StorageConnectorApi;
import lombok.Getter;
import lombok.Setter;
//import org.apache.spark.sql.Dataset;
//import org.apache.spark.sql.Row;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Query {
private static final Logger LOGGER = LoggerFactory.getLogger(FeatureGroup.class);
@Getter
@Setter
private FeatureGroupBase leftFeatureGroup;
@Getter
@Setter
private List<Feature> leftFeatures;
@Getter
@Setter
private Long leftFeatureGroupStartTime;
@Getter
@Setter
private Long leftFeatureGroupEndTime;
@Getter
@Setter
private List<Join> joins = new ArrayList<>();
@Getter
@Setter
private FilterLogic filter;
@Getter
@Setter
private Boolean hiveEngine = false;
private QueryConstructorApi queryConstructorApi;
private StorageConnectorApi storageConnectorApi;
private Utils utils = new Utils();
public Query(FeatureGroupBase leftFeatureGroup, List<Feature> leftFeatures) {
this.leftFeatureGroup = leftFeatureGroup;
this.leftFeatures = leftFeatures;
this.queryConstructorApi = new QueryConstructorApi();
this.storageConnectorApi = new StorageConnectorApi();
}
public Query join(Query subquery) {
return join(subquery, JoinType.INNER);
}
public Query join(Query subquery, String prefix) {
return join(subquery, JoinType.INNER, prefix);
}
public Query join(Query subquery, List<String> on) {
return joinFeatures(subquery, on.stream().map(Feature::new).collect(Collectors.toList()), JoinType.INNER);
}
public Query join(Query subquery, List<String> leftOn, List<String> rightOn) {
return joinFeatures(subquery, leftOn.stream().map(Feature::new).collect(Collectors.toList()),
rightOn.stream().map(Feature::new).collect(Collectors.toList()), JoinType.INNER);
}
public Query join(Query subquery, List<String> leftOn, List<String> rightOn, String prefix) {
return joinFeatures(subquery, leftOn.stream().map(Feature::new).collect(Collectors.toList()),
rightOn.stream().map(Feature::new).collect(Collectors.toList()), JoinType.INNER, prefix);
}
public Query join(Query subquery, JoinType joinType) {
joins.add(new Join(subquery, joinType, null));
return this;
}
public Query join(Query subquery, JoinType joinType, String prefix) {
joins.add(new Join(subquery, joinType, prefix));
return this;
}
public Query join(Query subquery, List<String> on, JoinType joinType) {
joins.add(new Join(subquery, on.stream().map(Feature::new).collect(Collectors.toList()), joinType, null));
return this;
}
public Query join(Query subquery, List<String> on, JoinType joinType, String prefix) {
joins.add(new Join(subquery, on.stream().map(Feature::new).collect(Collectors.toList()), joinType, prefix));
return this;
}
public Query join(Query subquery, List<String> leftOn, List<String> rightOn, JoinType joinType) {
joins.add(new Join(subquery, leftOn.stream().map(Feature::new).collect(Collectors.toList()),
rightOn.stream().map(Feature::new).collect(Collectors.toList()), joinType, null));
return this;
}
public Query join(Query subquery, List<String> leftOn, List<String> rightOn, JoinType joinType, String prefix) {
joins.add(new Join(subquery, leftOn.stream().map(Feature::new).collect(Collectors.toList()),
rightOn.stream().map(Feature::new).collect(Collectors.toList()), joinType, prefix));
return this;
}
public Query joinFeatures(Query subquery, List<Feature> on) {
return joinFeatures(subquery, on, JoinType.INNER);
}
public Query joinFeatures(Query subquery, List<Feature> on, String prefix) {
return joinFeatures(subquery, on, JoinType.INNER, prefix);
}
public Query joinFeatures(Query subquery, List<Feature> leftOn, List<Feature> rightOn) {
return joinFeatures(subquery, leftOn, rightOn, JoinType.INNER);
}
public Query joinFeatures(Query subquery, List<Feature> leftOn, List<Feature> rightOn, String prefix) {
return joinFeatures(subquery, leftOn, rightOn, JoinType.INNER, prefix);
}
public Query joinFeatures(Query subquery, List<Feature> on, JoinType joinType) {
joins.add(new Join(subquery, on, joinType, null));
return this;
}
public Query joinFeatures(Query subquery, List<Feature> on, JoinType joinType, String prefix) {
joins.add(new Join(subquery, on, joinType, prefix));
return this;
}
public Query joinFeatures(Query subquery, List<Feature> leftOn, List<Feature> rightOn, JoinType joinType) {
joins.add(new Join(subquery, leftOn, rightOn, joinType, null));
return this;
}
public Query joinFeatures(Query subquery, List<Feature> leftOn, List<Feature> rightOn, JoinType joinType,
String prefix) {
joins.add(new Join(subquery, leftOn, rightOn, joinType, prefix));
return this;
}
/**
* Reads Feature group data at a specific point in time.
*
* @param wallclockTime point in time
* @return Query
* @throws FeatureStoreException
* @throws ParseException
*/
public Query asOf(String wallclockTime) throws FeatureStoreException, ParseException {
Long wallclockTimestamp = utils.getTimeStampFromDateString(wallclockTime);
for (Join join : this.joins) {
Query queryWithTimeStamp = join.getQuery();
queryWithTimeStamp.setLeftFeatureGroupEndTime(wallclockTimestamp);
join.setQuery(queryWithTimeStamp);
}
this.setLeftFeatureGroupEndTime(wallclockTimestamp);
return this;
}
/**
* Reads changes that occurred between specified points in time.
*
* @param wallclockStartTime start date.
* @param wallclockEndTime end date.
* @return Query
* @throws FeatureStoreException
* @throws IOException
* @throws ParseException
*/
public Query pullChanges(String wallclockStartTime, String wallclockEndTime)
throws FeatureStoreException, ParseException {
this.setLeftFeatureGroupStartTime(utils.getTimeStampFromDateString(wallclockStartTime));
this.setLeftFeatureGroupEndTime(utils.getTimeStampFromDateString(wallclockEndTime));
return this;
}
/*
public Dataset<Row> read() throws FeatureStoreException, IOException {
return read(false, null);
}
public Dataset<Row> read(boolean online) throws FeatureStoreException, IOException {
return read(online, null);
}
public Dataset<Row> read(boolean online, Map<String, String> readOptions) throws FeatureStoreException, IOException {
FsQuery fsQuery = queryConstructorApi.constructQuery(leftFeatureGroup.getFeatureStore(), this);
if (online) {
LOGGER.info("Executing query: " + fsQuery.getStorageQuery(Storage.ONLINE));
StorageConnector onlineConnector =
storageConnectorApi.getOnlineStorageConnector(leftFeatureGroup.getFeatureStore());
return onlineConnector.read(fsQuery.getStorageQuery(Storage.ONLINE),null, null, null);
} else {
registerOnDemandFeatureGroups(fsQuery.getOnDemandFeatureGroups());
registerHudiFeatureGroups(fsQuery.getHudiCachedFeatureGroups(), readOptions);
LOGGER.info("Executing query: " + fsQuery.getStorageQuery(Storage.OFFLINE));
return SparkEngine.getInstance().sql(fsQuery.getStorageQuery(Storage.OFFLINE));
}
}
public void show(int numRows) throws FeatureStoreException, IOException {
show(false, numRows);
}
public void show(boolean online, int numRows) throws FeatureStoreException, IOException {
read(online).show(numRows);
}
*/
public String toString() {
return toString(Storage.OFFLINE);
}
public String toString(Storage storage) {
try {
return queryConstructorApi
.constructQuery(leftFeatureGroup.getFeatureStore(), this)
.getStorageQuery(storage);
} catch (FeatureStoreException | IOException e) {
return e.getMessage();
}
}
/*
private void registerOnDemandFeatureGroups(List<OnDemandFeatureGroupAlias> onDemandFeatureGroups)
throws FeatureStoreException, IOException {
if (onDemandFeatureGroups == null || onDemandFeatureGroups.isEmpty()) {
return;
}
for (OnDemandFeatureGroupAlias onDemandFeatureGroupAlias : onDemandFeatureGroups) {
String alias = onDemandFeatureGroupAlias.getAlias();
OnDemandFeatureGroup onDemandFeatureGroup = onDemandFeatureGroupAlias.getOnDemandFeatureGroup();
SparkEngine.getInstance().registerOnDemandTemporaryTable(onDemandFeatureGroup, alias);
}
}
private void registerHudiFeatureGroups(List<HudiFeatureGroupAlias> hudiFeatureGroups,
Map<String, String> readOptions) {
for (HudiFeatureGroupAlias hudiFeatureGroupAlias : hudiFeatureGroups) {
String alias = hudiFeatureGroupAlias.getAlias();
FeatureGroup featureGroup = hudiFeatureGroupAlias.getFeatureGroup();
SparkEngine.getInstance().registerHudiTemporaryTable(featureGroup, alias,
hudiFeatureGroupAlias.getLeftFeatureGroupStartTimestamp(),
hudiFeatureGroupAlias.getLeftFeatureGroupEndTimestamp(),
readOptions);
}
}
*/
public Query filter(Filter filter) {
if (this.filter == null) {
this.filter = new FilterLogic(filter);
} else {
this.filter = this.filter.and(filter);
}
return this;
}
public Query filter(FilterLogic filter) {
if (this.filter == null) {
this.filter = filter;
} else {
this.filter = this.filter.and(filter);
}
return this;
}
}
| [
"[email protected]"
] | |
e7a65506152fba9956f3eea09265686410c6d15c | 96342d1091241ac93d2d59366b873c8fedce8137 | /java/com/l2jolivia/gameserver/model/entity/FortSiege.java | c2d442a12bc29bc5b6416a9fc248709147e41cb3 | [] | no_license | soultobe/L2JOlivia_EpicEdition | c97ac7d232e429fa6f91d21bb9360cf347c7ee33 | 6f9b3de9f63d70fa2e281b49d139738e02d97cd6 | refs/heads/master | 2021-01-10T03:42:04.091432 | 2016-03-09T06:55:59 | 2016-03-09T06:55:59 | 53,468,281 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 33,214 | java | /*
* This file is part of the L2J Olivia project.
*
* This program 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 com.l2jolivia.gameserver.model.entity;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.l2jolivia.Config;
import com.l2jolivia.commons.database.DatabaseFactory;
import com.l2jolivia.gameserver.ThreadPoolManager;
import com.l2jolivia.gameserver.data.sql.impl.ClanTable;
import com.l2jolivia.gameserver.enums.ChatType;
import com.l2jolivia.gameserver.enums.FortTeleportWhoType;
import com.l2jolivia.gameserver.enums.SiegeClanType;
import com.l2jolivia.gameserver.instancemanager.FortManager;
import com.l2jolivia.gameserver.instancemanager.FortSiegeGuardManager;
import com.l2jolivia.gameserver.instancemanager.FortSiegeManager;
import com.l2jolivia.gameserver.model.CombatFlag;
import com.l2jolivia.gameserver.model.FortSiegeSpawn;
import com.l2jolivia.gameserver.model.L2Clan;
import com.l2jolivia.gameserver.model.L2Object;
import com.l2jolivia.gameserver.model.L2SiegeClan;
import com.l2jolivia.gameserver.model.L2Spawn;
import com.l2jolivia.gameserver.model.PcCondOverride;
import com.l2jolivia.gameserver.model.TeleportWhereType;
import com.l2jolivia.gameserver.model.actor.L2Npc;
import com.l2jolivia.gameserver.model.actor.instance.L2DoorInstance;
import com.l2jolivia.gameserver.model.actor.instance.L2FortCommanderInstance;
import com.l2jolivia.gameserver.model.actor.instance.L2PcInstance;
import com.l2jolivia.gameserver.model.events.EventDispatcher;
import com.l2jolivia.gameserver.model.events.impl.sieges.fort.OnFortSiegeFinish;
import com.l2jolivia.gameserver.model.events.impl.sieges.fort.OnFortSiegeStart;
import com.l2jolivia.gameserver.network.NpcStringId;
import com.l2jolivia.gameserver.network.SystemMessageId;
import com.l2jolivia.gameserver.network.serverpackets.NpcSay;
import com.l2jolivia.gameserver.network.serverpackets.SystemMessage;
public class FortSiege implements Siegable
{
protected static final Logger _log = Logger.getLogger(FortSiege.class.getName());
// SQL
private static final String DELETE_FORT_SIEGECLANS_BY_CLAN_ID = "DELETE FROM fortsiege_clans WHERE fort_id = ? AND clan_id = ?";
private static final String DELETE_FORT_SIEGECLANS = "DELETE FROM fortsiege_clans WHERE fort_id = ?";
public class ScheduleEndSiegeTask implements Runnable
{
@Override
public void run()
{
if (!isInProgress())
{
return;
}
try
{
_siegeEnd = null;
endSiege();
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: ScheduleEndSiegeTask() for Fort: " + _fort.getName() + " " + e.getMessage(), e);
}
}
}
public class ScheduleStartSiegeTask implements Runnable
{
private final Fort _fortInst;
private final int _time;
public ScheduleStartSiegeTask(int time)
{
_fortInst = _fort;
_time = time;
}
@Override
public void run()
{
if (isInProgress())
{
return;
}
try
{
final SystemMessage sm;
if (_time == 3600) // 1hr remains
{
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(600), 3000000); // Prepare task for 10 minutes left.
}
else if (_time == 600) // 10min remains
{
getFort().despawnSuspiciousMerchant();
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_MINUTE_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(10);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(300), 300000); // Prepare task for 5 minutes left.
}
else if (_time == 300) // 5min remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_MINUTE_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(5);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(60), 240000); // Prepare task for 1 minute left.
}
else if (_time == 60) // 1min remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_MINUTE_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(1);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(30), 30000); // Prepare task for 30 seconds left.
}
else if (_time == 30) // 30seconds remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_SECOND_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(30);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(10), 20000); // Prepare task for 10 seconds left.
}
else if (_time == 10) // 10seconds remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_SECOND_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(10);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(5), 5000); // Prepare task for 5 seconds left.
}
else if (_time == 5) // 5seconds remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_SECOND_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(5);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(1), 4000); // Prepare task for 1 seconds left.
}
else if (_time == 1) // 1seconds remains
{
sm = SystemMessage.getSystemMessage(SystemMessageId.S1_SECOND_S_UNTIL_THE_FORTRESS_BATTLE_STARTS);
sm.addInt(1);
announceToPlayer(sm);
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartSiegeTask(0), 1000); // Prepare task start siege.
}
else if (_time == 0)// start siege
{
_fortInst.getSiege().startSiege();
}
else
{
_log.warning("Exception: ScheduleStartSiegeTask(): unknown siege time: " + String.valueOf(_time));
}
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: ScheduleStartSiegeTask() for Fort: " + _fortInst.getName() + " " + e.getMessage(), e);
}
}
}
public class ScheduleSuspiciousMerchantSpawn implements Runnable
{
@Override
public void run()
{
if (isInProgress())
{
return;
}
try
{
_fort.spawnSuspiciousMerchant();
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: ScheduleSuspicoiusMerchantSpawn() for Fort: " + _fort.getName() + " " + e.getMessage(), e);
}
}
}
public class ScheduleSiegeRestore implements Runnable
{
@Override
public void run()
{
if (!isInProgress())
{
return;
}
try
{
_siegeRestore = null;
resetSiege();
announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.THE_BARRACKS_FUNCTION_HAS_BEEN_RESTORED));
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: ScheduleSiegeRestore() for Fort: " + _fort.getName() + " " + e.getMessage(), e);
}
}
}
private final List<L2SiegeClan> _attackerClans = new CopyOnWriteArrayList<>();
// Fort setting
protected List<L2Spawn> _commanders = new CopyOnWriteArrayList<>();
protected final Fort _fort;
private boolean _isInProgress = false;
private FortSiegeGuardManager _siegeGuardManager;
ScheduledFuture<?> _siegeEnd = null;
ScheduledFuture<?> _siegeRestore = null;
ScheduledFuture<?> _siegeStartTask = null;
public FortSiege(Fort fort)
{
_fort = fort;
checkAutoTask();
FortSiegeManager.getInstance().addSiege(this);
}
/**
* When siege ends.
*/
@Override
public void endSiege()
{
if (isInProgress())
{
_isInProgress = false; // Flag so that siege instance can be started
removeFlags(); // Removes all flags. Note: Remove flag before teleporting players
unSpawnFlags();
updatePlayerSiegeStateFlags(true);
int ownerId = -1;
if (getFort().getOwnerClan() != null)
{
ownerId = getFort().getOwnerClan().getId();
}
getFort().getZone().banishForeigners(ownerId);
getFort().getZone().setIsActive(false);
getFort().getZone().updateZoneStatusForCharactersInside();
getFort().getZone().setSiegeInstance(null);
saveFortSiege(); // Save fort specific data
clearSiegeClan(); // Clear siege clan from db
removeCommanders(); // Remove commander from this fort
getFort().spawnNpcCommanders(); // Spawn NPC commanders
getSiegeGuardManager().unspawnSiegeGuard(); // Remove all spawned siege guard from this fort
getFort().resetDoors(); // Respawn door to fort
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleSuspiciousMerchantSpawn(), FortSiegeManager.getInstance().getSuspiciousMerchantRespawnDelay() * 60 * 1000L); // Prepare 3hr task for suspicious merchant respawn
setSiegeDateTime(true); // store suspicious merchant spawn in DB
if (_siegeEnd != null)
{
_siegeEnd.cancel(true);
_siegeEnd = null;
}
if (_siegeRestore != null)
{
_siegeRestore.cancel(true);
_siegeRestore = null;
}
if ((getFort().getOwnerClan() != null) && (getFort().getFlagPole().getMeshIndex() == 0))
{
getFort().setVisibleFlag(true);
}
_log.info("Siege of " + getFort().getName() + " fort finished.");
// Notify to scripts.
EventDispatcher.getInstance().notifyEventAsync(new OnFortSiegeFinish(this), getFort());
}
}
/**
* When siege starts
*/
@Override
public void startSiege()
{
if (!isInProgress())
{
if (_siegeStartTask != null) // used admin command "admin_startfortsiege"
{
_siegeStartTask.cancel(true);
getFort().despawnSuspiciousMerchant();
}
_siegeStartTask = null;
if (getAttackerClans().isEmpty())
{
return;
}
_isInProgress = true; // Flag so that same siege instance cannot be started again
loadSiegeClan(); // Load siege clan from db
updatePlayerSiegeStateFlags(false);
teleportPlayer(FortTeleportWhoType.Attacker, TeleportWhereType.TOWN); // Teleport to the closest town
getFort().despawnNpcCommanders(); // Despawn NPC commanders
spawnCommanders(); // Spawn commanders
getFort().resetDoors(); // Spawn door
spawnSiegeGuard(); // Spawn siege guard
getFort().setVisibleFlag(false);
getFort().getZone().setSiegeInstance(this);
getFort().getZone().setIsActive(true);
getFort().getZone().updateZoneStatusForCharactersInside();
// Schedule a task to prepare auto siege end
_siegeEnd = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndSiegeTask(), FortSiegeManager.getInstance().getSiegeLength() * 60 * 1000L); // Prepare auto end task
final SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.THE_FORTRESS_BATTLE_S1_HAS_BEGUN);
sm.addCastleId(getFort().getResidenceId());
announceToPlayer(sm);
saveFortSiege();
_log.info("Siege of " + getFort().getName() + " fort started.");
// Notify to scripts.
EventDispatcher.getInstance().notifyEventAsync(new OnFortSiegeStart(this), getFort());
}
}
/**
* Announce to player.
* @param sm the system message to send to player
*/
public void announceToPlayer(SystemMessage sm)
{
// announce messages only for participants
L2Clan clan;
for (L2SiegeClan siegeclan : getAttackerClans())
{
clan = ClanTable.getInstance().getClan(siegeclan.getClanId());
for (L2PcInstance member : clan.getOnlineMembers(0))
{
member.sendPacket(sm);
}
}
if (getFort().getOwnerClan() != null)
{
clan = ClanTable.getInstance().getClan(getFort().getOwnerClan().getId());
for (L2PcInstance member : clan.getOnlineMembers(0))
{
if (member != null)
{
member.sendPacket(sm);
}
}
}
}
public void announceToPlayer(SystemMessage sm, String s)
{
sm.addString(s);
announceToPlayer(sm);
}
public void updatePlayerSiegeStateFlags(boolean clear)
{
L2Clan clan;
for (L2SiegeClan siegeclan : getAttackerClans())
{
clan = ClanTable.getInstance().getClan(siegeclan.getClanId());
for (L2PcInstance member : clan.getOnlineMembers(0))
{
if (clear)
{
member.setSiegeState((byte) 0);
member.setSiegeSide(0);
member.setIsInSiege(false);
member.stopFameTask();
}
else
{
member.setSiegeState((byte) 1);
member.setSiegeSide(getFort().getResidenceId());
if (checkIfInZone(member))
{
member.setIsInSiege(true);
member.startFameTask(Config.FORTRESS_ZONE_FAME_TASK_FREQUENCY * 1000, Config.FORTRESS_ZONE_FAME_AQUIRE_POINTS);
}
}
member.broadcastUserInfo();
}
}
if (getFort().getOwnerClan() != null)
{
clan = ClanTable.getInstance().getClan(getFort().getOwnerClan().getId());
for (L2PcInstance member : clan.getOnlineMembers(0))
{
if (member == null)
{
continue;
}
if (clear)
{
member.setSiegeState((byte) 0);
member.setSiegeSide(0);
member.setIsInSiege(false);
member.stopFameTask();
}
else
{
member.setSiegeState((byte) 2);
member.setSiegeSide(getFort().getResidenceId());
if (checkIfInZone(member))
{
member.setIsInSiege(true);
member.startFameTask(Config.FORTRESS_ZONE_FAME_TASK_FREQUENCY * 1000, Config.FORTRESS_ZONE_FAME_AQUIRE_POINTS);
}
}
member.broadcastUserInfo();
}
}
}
/**
* @param object
* @return true if object is inside the zone
*/
public boolean checkIfInZone(L2Object object)
{
return checkIfInZone(object.getX(), object.getY(), object.getZ());
}
/**
* @param x
* @param y
* @param z
* @return true if object is inside the zone
*/
public boolean checkIfInZone(int x, int y, int z)
{
return (isInProgress() && (getFort().checkIfInZone(x, y, z))); // Fort zone during siege
}
/**
* @param clan The L2Clan of the player
* @return true if clan is attacker
*/
@Override
public boolean checkIsAttacker(L2Clan clan)
{
return (getAttackerClan(clan) != null);
}
/**
* @param clan The L2Clan of the player
* @return true if clan is defender
*/
@Override
public boolean checkIsDefender(L2Clan clan)
{
if ((clan != null) && (getFort().getOwnerClan() == clan))
{
return true;
}
return false;
}
/** Clear all registered siege clans from database for fort */
public void clearSiegeClan()
{
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement ps = con.prepareStatement("DELETE FROM fortsiege_clans WHERE fort_id=?"))
{
ps.setInt(1, getFort().getResidenceId());
ps.execute();
if (getFort().getOwnerClan() != null)
{
try (PreparedStatement delete = con.prepareStatement("DELETE FROM fortsiege_clans WHERE clan_id=?"))
{
delete.setInt(1, getFort().getOwnerClan().getId());
delete.execute();
}
}
getAttackerClans().clear();
// if siege is in progress, end siege
if (isInProgress())
{
endSiege();
}
// if siege isn't in progress (1hr waiting time till siege starts), cancel waiting time
if (_siegeStartTask != null)
{
_siegeStartTask.cancel(true);
_siegeStartTask = null;
}
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: clearSiegeClan(): " + e.getMessage(), e);
}
}
/** Set the date for the next siege. */
private void clearSiegeDate()
{
getFort().getSiegeDate().setTimeInMillis(0);
}
/**
* @return list of L2PcInstance registered as attacker in the zone.
*/
@Override
public List<L2PcInstance> getAttackersInZone()
{
final List<L2PcInstance> players = new LinkedList<>();
for (L2SiegeClan siegeclan : getAttackerClans())
{
final L2Clan clan = ClanTable.getInstance().getClan(siegeclan.getClanId());
for (L2PcInstance player : clan.getOnlineMembers(0))
{
if (player.isInSiege())
{
players.add(player);
}
}
}
return players;
}
/**
* @return list of L2PcInstance in the zone.
*/
public List<L2PcInstance> getPlayersInZone()
{
return getFort().getZone().getPlayersInside();
}
/**
* @return list of L2PcInstance owning the fort in the zone.
*/
public List<L2PcInstance> getOwnersInZone()
{
final List<L2PcInstance> players = new LinkedList<>();
if (getFort().getOwnerClan() != null)
{
final L2Clan clan = ClanTable.getInstance().getClan(getFort().getOwnerClan().getId());
if (clan != getFort().getOwnerClan())
{
return null;
}
for (L2PcInstance player : clan.getOnlineMembers(0))
{
if (player.isInSiege())
{
players.add(player);
}
}
}
return players;
}
/**
* TODO: To DP AI<br>
* Commander was killed
* @param instance
*/
public void killedCommander(L2FortCommanderInstance instance)
{
if (!_commanders.isEmpty() && (getFort() != null))
{
final L2Spawn spawn = instance.getSpawn();
if (spawn != null)
{
final List<FortSiegeSpawn> commanders = FortSiegeManager.getInstance().getCommanderSpawnList(getFort().getResidenceId());
for (FortSiegeSpawn spawn2 : commanders)
{
if (spawn2.getId() == spawn.getId())
{
NpcStringId npcString = null;
switch (spawn2.getMessageId())
{
case 1:
{
npcString = NpcStringId.YOU_MAY_HAVE_BROKEN_OUR_ARROWS_BUT_YOU_WILL_NEVER_BREAK_OUR_WILL_ARCHERS_RETREAT;
break;
}
case 2:
{
npcString = NpcStringId.AIIEEEE_COMMAND_CENTER_THIS_IS_GUARD_UNIT_WE_NEED_BACKUP_RIGHT_AWAY;
break;
}
case 3:
{
npcString = NpcStringId.AT_LAST_THE_MAGIC_CIRCLE_THAT_PROTECTS_THE_FORTRESS_HAS_WEAKENED_VOLUNTEERS_STAND_BACK;
break;
}
case 4:
{
npcString = NpcStringId.I_FEEL_SO_MUCH_GRIEF_THAT_I_CAN_T_EVEN_TAKE_CARE_OF_MYSELF_THERE_ISN_T_ANY_REASON_FOR_ME_TO_STAY_HERE_ANY_LONGER;
break;
}
}
if (npcString != null)
{
instance.broadcastPacket(new NpcSay(instance.getObjectId(), ChatType.NPC_SHOUT, instance.getId(), npcString));
}
}
}
_commanders.remove(spawn);
if (_commanders.isEmpty())
{
// spawn fort flags
spawnFlag(getFort().getResidenceId());
// cancel door/commanders respawn
if (_siegeRestore != null)
{
_siegeRestore.cancel(true);
}
// open doors in main building
for (L2DoorInstance door : getFort().getDoors())
{
if (door.getIsShowHp())
{
continue;
}
// TODO this also opens control room door at big fort
door.openMe();
}
getFort().getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.ALL_BARRACKS_ARE_OCCUPIED));
}
// schedule restoring doors/commanders respawn
else if (_siegeRestore == null)
{
getFort().getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.THE_BARRACKS_HAVE_BEEN_SEIZED));
_siegeRestore = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleSiegeRestore(), FortSiegeManager.getInstance().getCountDownLength() * 60 * 1000L);
}
else
{
getFort().getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.THE_BARRACKS_HAVE_BEEN_SEIZED));
}
}
else
{
_log.warning("FortSiege.killedCommander(): killed commander, but commander not registered for fortress. NpcId: " + instance.getId() + " FortId: " + getFort().getResidenceId());
}
}
}
/**
* Remove the flag that was killed
* @param flag
*/
public void killedFlag(L2Npc flag)
{
if (flag == null)
{
return;
}
for (L2SiegeClan clan : getAttackerClans())
{
if (clan.removeFlag(flag))
{
return;
}
}
}
/**
* Register clan as attacker.<BR>
* @param player The L2PcInstance of the player trying to register.
* @param checkConditions True if should be checked conditions, false otherwise
* @return Number that defines what happened. <BR>
* 0 - Player don't have clan.<BR>
* 1 - Player don't have enough adena to register.<BR>
* 2 - Is not right time to register Fortress now.<BR>
* 3 - Players clan is already registered to siege.<BR>
* 4 - Players clan is successfully registered to siege.
*/
public int addAttacker(L2PcInstance player, boolean checkConditions)
{
if (player.getClan() == null)
{
return 0; // Player dont have clan
}
if (checkConditions)
{
if (getFort().getSiege().getAttackerClans().isEmpty() && (player.getInventory().getAdena() < 250000))
{
return 1; // Player don't have enough adena to register
}
for (Fort fort : FortManager.getInstance().getForts())
{
if (fort.getSiege().getAttackerClan(player.getClanId()) != null)
{
return 3; // Players clan is already registered to siege
}
if ((fort.getOwnerClan() == player.getClan()) && (fort.getSiege().isInProgress() || (fort.getSiege()._siegeStartTask != null)))
{
return 3; // Players clan is already registered to siege
}
}
}
saveSiegeClan(player.getClan());
if (getAttackerClans().size() == 1)
{
if (checkConditions)
{
player.reduceAdena("FortressSiege", 250000, null, true);
}
startAutoTask(true);
}
return 4; // Players clan is successfully registered to siege
}
/**
* Remove clan from siege
* @param clan The clan being removed
*/
public void removeAttacker(L2Clan clan)
{
if ((clan == null) || (clan.getFortId() == getFort().getResidenceId()) || !FortSiegeManager.getInstance().checkIsRegistered(clan, getFort().getResidenceId()))
{
return;
}
removeSiegeClan(clan.getId());
}
/**
* This function does not do any checks and should not be called from bypass !
* @param clanId
*/
private void removeSiegeClan(int clanId)
{
final String query = (clanId != 0) ? DELETE_FORT_SIEGECLANS_BY_CLAN_ID : DELETE_FORT_SIEGECLANS;
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement ps = con.prepareStatement(query))
{
ps.setInt(1, getFort().getResidenceId());
if (clanId != 0)
{
ps.setInt(2, clanId);
}
ps.execute();
loadSiegeClan();
if (getAttackerClans().isEmpty())
{
if (isInProgress())
{
endSiege();
}
else
{
saveFortSiege(); // Clear siege time in DB
}
if (_siegeStartTask != null)
{
_siegeStartTask.cancel(true);
_siegeStartTask = null;
}
}
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception on removeSiegeClan: " + e.getMessage(), e);
}
}
/**
* Start the auto tasks
*/
public void checkAutoTask()
{
if (_siegeStartTask != null)
{
return;
}
final long delay = getFort().getSiegeDate().getTimeInMillis() - Calendar.getInstance().getTimeInMillis();
if (delay < 0)
{
// siege time in past
saveFortSiege();
clearSiegeClan(); // remove all clans
// spawn suspicious merchant immediately
ThreadPoolManager.getInstance().executeGeneral(new ScheduleSuspiciousMerchantSpawn());
}
else
{
loadSiegeClan();
if (getAttackerClans().isEmpty())
{
// no attackers - waiting for suspicious merchant spawn
ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleSuspiciousMerchantSpawn(), delay);
}
else
{
// preparing start siege task
if (delay > 3600000) // more than hour, how this can happens ? spawn suspicious merchant
{
ThreadPoolManager.getInstance().executeGeneral(new ScheduleSuspiciousMerchantSpawn());
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(3600), delay - 3600000);
}
if (delay > 600000) // more than 10 min, spawn suspicious merchant
{
ThreadPoolManager.getInstance().executeGeneral(new ScheduleSuspiciousMerchantSpawn());
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(600), delay - 600000);
}
else if (delay > 300000)
{
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(300), delay - 300000);
}
else if (delay > 60000)
{
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(60), delay - 60000);
}
else
{
// lower than 1 min, set to 1 min
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(60), 0);
}
_log.info("Siege of " + getFort().getName() + " fort: " + getFort().getSiegeDate().getTime());
}
}
}
/**
* Start the auto task
* @param setTime
*/
public void startAutoTask(boolean setTime)
{
if (_siegeStartTask != null)
{
return;
}
if (setTime)
{
setSiegeDateTime(false);
}
if (getFort().getOwnerClan() != null)
{
getFort().getOwnerClan().broadcastToOnlineMembers(SystemMessage.getSystemMessage(SystemMessageId.A_FORTRESS_IS_UNDER_ATTACK));
}
// Execute siege auto start
_siegeStartTask = ThreadPoolManager.getInstance().scheduleGeneral(new FortSiege.ScheduleStartSiegeTask(3600), 0);
}
/**
* Teleport players
* @param teleportWho
* @param teleportWhere
*/
public void teleportPlayer(FortTeleportWhoType teleportWho, TeleportWhereType teleportWhere)
{
List<L2PcInstance> players;
switch (teleportWho)
{
case Owner:
{
players = getOwnersInZone();
break;
}
case Attacker:
{
players = getAttackersInZone();
break;
}
default:
{
players = getPlayersInZone();
}
}
for (L2PcInstance player : players)
{
if (player.canOverrideCond(PcCondOverride.FORTRESS_CONDITIONS) || player.isJailed())
{
continue;
}
player.teleToLocation(teleportWhere);
}
}
/**
* Add clan as attacker<
* @param clanId
*/
private void addAttacker(int clanId)
{
getAttackerClans().add(new L2SiegeClan(clanId, SiegeClanType.ATTACKER)); // Add registered attacker to attacker list
}
/**
* @param clan
* @return {@code true} if the clan has already registered to a siege for the same day, {@code false} otherwise.
*/
public boolean checkIfAlreadyRegisteredForSameDay(L2Clan clan)
{
for (FortSiege siege : FortSiegeManager.getInstance().getSieges())
{
if (siege == this)
{
continue;
}
if (siege.getSiegeDate().get(Calendar.DAY_OF_WEEK) == getSiegeDate().get(Calendar.DAY_OF_WEEK))
{
if (siege.checkIsAttacker(clan))
{
return true;
}
if (siege.checkIsDefender(clan))
{
return true;
}
}
}
return false;
}
private void setSiegeDateTime(boolean merchant)
{
final Calendar newDate = Calendar.getInstance();
if (merchant)
{
newDate.add(Calendar.MINUTE, FortSiegeManager.getInstance().getSuspiciousMerchantRespawnDelay());
}
else
{
newDate.add(Calendar.MINUTE, 60);
}
getFort().setSiegeDate(newDate);
saveSiegeDate();
}
/** Load siege clans. */
private void loadSiegeClan()
{
getAttackerClans().clear();
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement ps = con.prepareStatement("SELECT clan_id FROM fortsiege_clans WHERE fort_id=?"))
{
ps.setInt(1, getFort().getResidenceId());
try (ResultSet rs = ps.executeQuery())
{
while (rs.next())
{
addAttacker(rs.getInt("clan_id"));
}
}
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: loadSiegeClan(): " + e.getMessage(), e);
}
}
/** Remove commanders. */
private void removeCommanders()
{
if ((_commanders != null) && !_commanders.isEmpty())
{
// Remove all instance of commanders for this fort
for (L2Spawn spawn : _commanders)
{
if (spawn != null)
{
spawn.stopRespawn();
if (spawn.getLastSpawn() != null)
{
spawn.getLastSpawn().deleteMe();
}
}
}
_commanders.clear();
}
}
/** Remove all flags. */
private void removeFlags()
{
for (L2SiegeClan sc : getAttackerClans())
{
if (sc != null)
{
sc.removeFlags();
}
}
}
/** Save fort siege related to database. */
private void saveFortSiege()
{
clearSiegeDate(); // clear siege date
saveSiegeDate(); // Save the new date
}
/** Save siege date to database. */
private void saveSiegeDate()
{
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement ps = con.prepareStatement("UPDATE fort SET siegeDate = ? WHERE id = ?"))
{
ps.setLong(1, getSiegeDate().getTimeInMillis());
ps.setInt(2, getFort().getResidenceId());
ps.execute();
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: saveSiegeDate(): " + e.getMessage(), e);
}
}
/**
* Save registration to database.
* @param clan
*/
private void saveSiegeClan(L2Clan clan)
{
if (getAttackerClans().size() >= FortSiegeManager.getInstance().getAttackerMaxClans())
{
return;
}
try (Connection con = DatabaseFactory.getInstance().getConnection();
PreparedStatement ps = con.prepareStatement("INSERT INTO fortsiege_clans (clan_id,fort_id) values (?,?)"))
{
ps.setInt(1, clan.getId());
ps.setInt(2, getFort().getResidenceId());
ps.execute();
addAttacker(clan.getId());
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception: saveSiegeClan(L2Clan clan): " + e.getMessage(), e);
}
}
/** Spawn commanders. */
private void spawnCommanders()
{
// Set commanders array size if one does not exist
try
{
_commanders.clear();
for (FortSiegeSpawn _sp : FortSiegeManager.getInstance().getCommanderSpawnList(getFort().getResidenceId()))
{
final L2Spawn spawnDat = new L2Spawn(_sp.getId());
spawnDat.setAmount(1);
spawnDat.setX(_sp.getLocation().getX());
spawnDat.setY(_sp.getLocation().getY());
spawnDat.setZ(_sp.getLocation().getZ());
spawnDat.setHeading(_sp.getLocation().getHeading());
spawnDat.setRespawnDelay(60);
spawnDat.doSpawn();
spawnDat.stopRespawn();
_commanders.add(spawnDat);
}
}
catch (Exception e)
{
// problem with initializing spawn, go to next one
_log.log(Level.WARNING, "FortSiege.spawnCommander: Spawn could not be initialized: " + e.getMessage(), e);
}
}
private void spawnFlag(int Id)
{
for (CombatFlag cf : FortSiegeManager.getInstance().getFlagList(Id))
{
cf.spawnMe();
}
}
private void unSpawnFlags()
{
if (FortSiegeManager.getInstance().getFlagList(getFort().getResidenceId()) == null)
{
return;
}
for (CombatFlag cf : FortSiegeManager.getInstance().getFlagList(getFort().getResidenceId()))
{
cf.unSpawnMe();
}
}
/**
* Spawn siege guard.
*/
private void spawnSiegeGuard()
{
getSiegeGuardManager().spawnSiegeGuard();
}
@Override
public final L2SiegeClan getAttackerClan(L2Clan clan)
{
if (clan == null)
{
return null;
}
return getAttackerClan(clan.getId());
}
@Override
public final L2SiegeClan getAttackerClan(int clanId)
{
for (L2SiegeClan sc : getAttackerClans())
{
if ((sc != null) && (sc.getClanId() == clanId))
{
return sc;
}
}
return null;
}
@Override
public final List<L2SiegeClan> getAttackerClans()
{
return _attackerClans;
}
public final Fort getFort()
{
return _fort;
}
public final boolean isInProgress()
{
return _isInProgress;
}
@Override
public final Calendar getSiegeDate()
{
return getFort().getSiegeDate();
}
@Override
public List<L2Npc> getFlag(L2Clan clan)
{
if (clan != null)
{
final L2SiegeClan sc = getAttackerClan(clan);
if (sc != null)
{
return sc.getFlag();
}
}
return null;
}
public final FortSiegeGuardManager getSiegeGuardManager()
{
if (_siegeGuardManager == null)
{
_siegeGuardManager = new FortSiegeGuardManager(getFort());
}
return _siegeGuardManager;
}
public void resetSiege()
{
// reload commanders and repair doors
removeCommanders();
spawnCommanders();
getFort().resetDoors();
}
public List<L2Spawn> getCommanders()
{
return _commanders;
}
@Override
public L2SiegeClan getDefenderClan(int clanId)
{
return null;
}
@Override
public L2SiegeClan getDefenderClan(L2Clan clan)
{
return null;
}
@Override
public List<L2SiegeClan> getDefenderClans()
{
return null;
}
@Override
public boolean giveFame()
{
return true;
}
@Override
public int getFameFrequency()
{
return Config.FORTRESS_ZONE_FAME_TASK_FREQUENCY;
}
@Override
public int getFameAmount()
{
return Config.FORTRESS_ZONE_FAME_AQUIRE_POINTS;
}
@Override
public void updateSiege()
{
}
}
| [
"[email protected]"
] | |
46f13e71dc6b76938a9951c5fbc68d961518d544 | 1ac0c3219e44db71950e79acac8ecf370f8e2a7b | /src/chrome/android/javatests/src/org/chromium/chrome/browser/preferences/password/SavePasswordsPreferencesTest.java | 5f35e3ad7b521abbe6f30361e38df96fc09845dd | [
"BSD-3-Clause"
] | permissive | yeahhhhhhhh/chromium_quic | 5383c74ca3665c4639899a2aa5741ca2efa39ffb | 217d9cdd739b3cc9a440ecea38813c0ce85ef251 | refs/heads/master | 2022-12-08T04:12:54.583056 | 2019-08-19T15:03:52 | 2019-08-19T15:03:52 | 203,185,892 | 1 | 3 | null | 2022-11-19T05:44:25 | 2019-08-19T14:09:51 | null | UTF-8 | Java | false | false | 94,366 | java | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.chrome.browser.preferences.password;
import static android.support.test.espresso.Espresso.openActionBarOverflowOrOptionsMenu;
import static android.support.test.espresso.action.ViewActions.click;
import static android.support.test.espresso.action.ViewActions.closeSoftKeyboard;
import static android.support.test.espresso.action.ViewActions.typeText;
import static android.support.test.espresso.assertion.ViewAssertions.doesNotExist;
import static android.support.test.espresso.assertion.ViewAssertions.matches;
import static android.support.test.espresso.intent.Intents.intended;
import static android.support.test.espresso.intent.Intents.intending;
import static android.support.test.espresso.intent.matcher.BundleMatchers.hasEntry;
import static android.support.test.espresso.intent.matcher.IntentMatchers.hasAction;
import static android.support.test.espresso.intent.matcher.IntentMatchers.hasData;
import static android.support.test.espresso.intent.matcher.IntentMatchers.hasExtras;
import static android.support.test.espresso.intent.matcher.IntentMatchers.hasType;
import static android.support.test.espresso.intent.matcher.UriMatchers.hasHost;
import static android.support.test.espresso.matcher.RootMatchers.withDecorView;
import static android.support.test.espresso.matcher.ViewMatchers.isAssignableFrom;
import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
import static android.support.test.espresso.matcher.ViewMatchers.isEnabled;
import static android.support.test.espresso.matcher.ViewMatchers.isRoot;
import static android.support.test.espresso.matcher.ViewMatchers.withContentDescription;
import static android.support.test.espresso.matcher.ViewMatchers.withId;
import static android.support.test.espresso.matcher.ViewMatchers.withParent;
import static android.support.test.espresso.matcher.ViewMatchers.withText;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.chromium.chrome.test.util.ViewUtils.VIEW_GONE;
import static org.chromium.chrome.test.util.ViewUtils.VIEW_INVISIBLE;
import static org.chromium.chrome.test.util.ViewUtils.VIEW_NULL;
import static org.chromium.chrome.test.util.ViewUtils.waitForView;
import android.app.Activity;
import android.app.Instrumentation;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.ColorFilter;
import android.graphics.drawable.Drawable;
import android.support.annotation.IdRes;
import android.support.annotation.IntDef;
import android.support.annotation.Nullable;
import android.support.annotation.StringRes;
import android.support.test.InstrumentationRegistry;
import android.support.test.espresso.Espresso;
import android.support.test.espresso.intent.Intents;
import android.support.test.espresso.intent.rule.IntentsTestRule;
import android.support.test.filters.SmallTest;
import android.support.v4.graphics.drawable.DrawableCompat;
import android.support.v7.view.menu.ActionMenuItemView;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import org.hamcrest.Matcher;
import org.junit.After;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
import org.junit.runner.RunWith;
import org.chromium.base.Callback;
import org.chromium.base.CollectionUtil;
import org.chromium.base.IntStringCallback;
import org.chromium.base.test.BaseJUnit4ClassRunner;
import org.chromium.base.test.util.Feature;
import org.chromium.chrome.R;
import org.chromium.chrome.browser.ChromeFeatureList;
import org.chromium.chrome.browser.history.HistoryActivity;
import org.chromium.chrome.browser.history.HistoryManager;
import org.chromium.chrome.browser.history.StubbedHistoryProvider;
import org.chromium.chrome.browser.preferences.ChromeBaseCheckBoxPreference;
import org.chromium.chrome.browser.preferences.ChromeSwitchPreference;
import org.chromium.chrome.browser.preferences.PrefServiceBridge;
import org.chromium.chrome.browser.preferences.Preferences;
import org.chromium.chrome.browser.preferences.PreferencesTest;
import org.chromium.chrome.browser.sync.ProfileSyncService;
import org.chromium.chrome.test.ChromeBrowserTestRule;
import org.chromium.chrome.test.util.browser.Features;
import org.chromium.components.signin.ChromeSigninController;
import org.chromium.components.sync.ModelType;
import org.chromium.content_public.browser.test.util.TestThreadUtils;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
/**
* Tests for the "Save Passwords" settings screen.
*/
@RunWith(BaseJUnit4ClassRunner.class)
public class SavePasswordsPreferencesTest {
private static final long UI_UPDATING_TIMEOUT_MS = 3000;
@Rule
public final ChromeBrowserTestRule mBrowserTestRule = new ChromeBrowserTestRule();
@Rule
public TestRule mProcessor = new Features.InstrumentationProcessor();
@Rule
public IntentsTestRule<HistoryActivity> mHistoryActivityTestRule =
new IntentsTestRule<>(HistoryActivity.class, false, false);
private static final class FakePasswordManagerHandler implements PasswordManagerHandler {
// This class has exactly one observer, set on construction and expected to last at least as
// long as this object (a good candidate is the owner of this object).
private final PasswordListObserver mObserver;
// The faked contents of the password store to be displayed.
private ArrayList<SavedPasswordEntry> mSavedPasswords = new ArrayList<SavedPasswordEntry>();
// The faked contents of the saves password exceptions to be displayed.
private ArrayList<String> mSavedPasswordExeptions = new ArrayList<>();
// The following three data members are set once {@link #serializePasswords()} is called.
@Nullable
private IntStringCallback mExportSuccessCallback;
@Nullable
private Callback<String> mExportErrorCallback;
@Nullable
private String mExportTargetPath;
public void setSavedPasswords(ArrayList<SavedPasswordEntry> savedPasswords) {
mSavedPasswords = savedPasswords;
}
public void setSavedPasswordExceptions(ArrayList<String> savedPasswordExceptions) {
mSavedPasswordExeptions = savedPasswordExceptions;
}
public IntStringCallback getExportSuccessCallback() {
return mExportSuccessCallback;
}
public Callback<String> getExportErrorCallback() {
return mExportErrorCallback;
}
public String getExportTargetPath() {
return mExportTargetPath;
}
/**
* Constructor.
* @param PasswordListObserver The only observer.
*/
public FakePasswordManagerHandler(PasswordListObserver observer) {
mObserver = observer;
}
// Pretends that the updated lists are |mSavedPasswords| for the saved passwords and an
// empty list for exceptions and immediately calls the observer.
@Override
public void updatePasswordLists() {
mObserver.passwordListAvailable(mSavedPasswords.size());
mObserver.passwordExceptionListAvailable(mSavedPasswordExeptions.size());
}
@Override
public SavedPasswordEntry getSavedPasswordEntry(int index) {
return mSavedPasswords.get(index);
}
@Override
public String getSavedPasswordException(int index) {
return mSavedPasswordExeptions.get(index);
}
@Override
public void changeSavedPasswordEntry(int index, String newUsername, String newPassword) {
mSavedPasswords.set(index,
new SavedPasswordEntry(
mSavedPasswords.get(index).getUrl(), newUsername, newPassword));
updatePasswordLists();
}
@Override
public void removeSavedPasswordEntry(int index) {
assert false : "Define this method before starting to use it in tests.";
}
@Override
public void removeSavedPasswordException(int index) {
assert false : "Define this method before starting to use it in tests.";
}
@Override
public void serializePasswords(String targetPath, IntStringCallback successCallback,
Callback<String> errorCallback) {
mExportSuccessCallback = successCallback;
mExportErrorCallback = errorCallback;
mExportTargetPath = targetPath;
}
}
private final static SavedPasswordEntry ZEUS_ON_EARTH =
new SavedPasswordEntry("http://www.phoenicia.gr", "Zeus", "Europa");
private final static SavedPasswordEntry ARES_AT_OLYMP =
new SavedPasswordEntry("https://1-of-12.olymp.gr", "Ares", "God-o'w@r");
private final static SavedPasswordEntry PHOBOS_AT_OLYMP =
new SavedPasswordEntry("https://visitor.olymp.gr", "Phobos-son-of-ares", "G0d0fF34r");
private final static SavedPasswordEntry DEIMOS_AT_OLYMP =
new SavedPasswordEntry("https://visitor.olymp.gr", "Deimops-Ares-son", "G0d0fT3rr0r");
private final static SavedPasswordEntry HADES_AT_UNDERWORLD =
new SavedPasswordEntry("https://underworld.gr", "", "C3rb3rus");
private final static SavedPasswordEntry[] GREEK_GODS = {
ZEUS_ON_EARTH, ARES_AT_OLYMP, PHOBOS_AT_OLYMP, DEIMOS_AT_OLYMP, HADES_AT_UNDERWORLD,
};
// Used to provide fake lists of stored passwords. Tests which need it can use setPasswordSource
// to instantiate it.
FakePasswordManagerHandler mHandler;
/**
* Delayer controling hiding the progress bar during exporting passwords. This replaces a time
* delay used in production.
*/
private final ManualCallbackDelayer mManualDelayer = new ManualCallbackDelayer();
private void overrideProfileSyncService(
final boolean usingPassphrase, final boolean syncingPasswords) {
TestThreadUtils.runOnUiThreadBlocking(() -> {
ProfileSyncService.overrideForTests(new ProfileSyncService() {
@Override
public boolean isUsingSecondaryPassphrase() {
return usingPassphrase;
}
@Override
public Set<Integer> getActiveDataTypes() {
if (syncingPasswords) return CollectionUtil.newHashSet(ModelType.PASSWORDS);
return CollectionUtil.newHashSet(ModelType.AUTOFILL);
}
});
});
}
@After
public void tearDown() throws Exception {
TestThreadUtils.runOnUiThreadBlocking(() -> ProfileSyncService.resetForTests());
}
/**
* Helper to set up a fake source of displayed passwords.
* @param entry An entry to be added to saved passwords. Can be null.
*/
private void setPasswordSource(SavedPasswordEntry entry) throws Exception {
SavedPasswordEntry[] entries = {};
if (entry != null) {
entries = new SavedPasswordEntry[] {entry};
}
setPasswordSourceWithMultipleEntries(entries);
}
/**
* Helper to set up a fake source of displayed passwords with multiple initial passwords.
* @param initialEntries All entries to be added to saved passwords. Can not be null.
*/
private void setPasswordSourceWithMultipleEntries(SavedPasswordEntry[] initialEntries)
throws Exception {
if (mHandler == null) {
mHandler = new FakePasswordManagerHandler(PasswordManagerHandlerProvider.getInstance());
}
ArrayList<SavedPasswordEntry> entries = new ArrayList<>(Arrays.asList(initialEntries));
mHandler.setSavedPasswords(entries);
TestThreadUtils.runOnUiThreadBlocking(
()
-> PasswordManagerHandlerProvider.getInstance()
.setPasswordManagerHandlerForTest(mHandler));
}
/**
* Helper to set up a fake source of displayed passwords without passwords but with exceptions.
* @param exceptions All exceptions to be added to saved exceptions. Can not be null.
*/
private void setPasswordExceptions(String[] exceptions) throws Exception {
if (mHandler == null) {
mHandler = new FakePasswordManagerHandler(PasswordManagerHandlerProvider.getInstance());
}
mHandler.setSavedPasswordExceptions(new ArrayList<>(Arrays.asList(exceptions)));
TestThreadUtils.runOnUiThreadBlocking(
()
-> PasswordManagerHandlerProvider.getInstance()
.setPasswordManagerHandlerForTest(mHandler));
}
/**
* Looks for the icon by id. If it cannot be found, it's probably hidden in the overflow
* menu. In that case, open the menu and search for its title.
* @return Returns either the icon button or the menu option.
*/
public static Matcher<View> withMenuIdOrText(@IdRes int actionId, @StringRes int actionLabel) {
Matcher<View> matcher = withId(actionId);
try {
Espresso.onView(matcher).check(matches(isDisplayed()));
return matcher;
} catch (Exception NoMatchingViewException) {
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
return withText(actionLabel);
}
}
/**
* Looks for the search icon by id or by its title.
* @return Returns either the icon button or the menu option.
*/
public static Matcher<View> withSearchMenuIdOrText() {
return withMenuIdOrText(R.id.menu_id_search, R.string.search);
}
/**
* Looks for the edit saved password icon by id or by its title.
* @return Returns either the icon button or the menu option.
*/
public static Matcher<View> withEditMenuIdOrText() {
return withMenuIdOrText(R.id.action_edit_saved_password,
R.string.password_entry_viewer_edit_stored_password_action_title);
}
/**
* Looks for the save edited password icon by id or by its title.
* @return Returns either the icon button or the menu option.
*/
public static Matcher<View> withSaveMenuIdOrText() {
return withMenuIdOrText(R.id.action_save_edited_password, R.string.save);
}
/**
* Taps the menu item to trigger exporting and ensures that reauthentication passes.
* It also disables the timer in {@link DialogManager} which is used to allow hiding the
* progress bar after an initial period. Hiding can be later allowed manually in tests with
* {@link #allowProgressBarToBeHidden}, to avoid time-dependent flakiness.
*/
private void reauthenticateAndRequestExport(Preferences preferences) {
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
// Avoid launching the Android-provided reauthentication challenge, which cannot be
// completed in the test.
ReauthenticationManager.setSkipSystemReauth(true);
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Now Chrome thinks it triggered the challenge and is waiting to be resumed. Once resumed
// it will check the reauthentication result. First, update the reauth timestamp to indicate
// a successful reauth:
ReauthenticationManager.recordLastReauth(
System.currentTimeMillis(), ReauthenticationManager.ReauthScope.BULK);
TestThreadUtils.runOnUiThreadBlocking(() -> {
// Disable the timer for progress bar.
SavePasswordsPreferences fragment =
(SavePasswordsPreferences) preferences.getMainFragment();
fragment.getExportFlowForTesting()
.getDialogManagerForTesting()
.replaceCallbackDelayerForTesting(mManualDelayer);
// Now call onResume to nudge Chrome into continuing the export flow.
preferences.getMainFragment().onResume();
});
}
@IntDef({MenuItemState.DISABLED, MenuItemState.ENABLED})
@Retention(RetentionPolicy.SOURCE)
private @interface MenuItemState {
/** Represents the state of an enabled menu item. */
int DISABLED = 0;
/** Represents the state of a disabled menu item. */
int ENABLED = 1;
}
/**
* Checks that the menu item for exporting passwords is enabled or disabled as expected.
* @param expectedState The expected state of the menu item.
*/
private void checkExportMenuItemState(@MenuItemState int expectedState) {
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
final Matcher<View> stateMatcher =
expectedState == MenuItemState.ENABLED ? isEnabled() : not(isEnabled());
// The text matches a text view, but the disabled entity is some wrapper two levels up in
// the view hierarchy, hence the two withParent matchers.
Espresso.onView(allOf(withText(R.string.save_password_preferences_export_action_title),
withParent(withParent(withParent(stateMatcher)))))
.check(matches(isDisplayed()));
}
/** Requests showing an arbitrary password export error. */
private void requestShowingExportError() {
TestThreadUtils.runOnUiThreadBlocking(
() -> { mHandler.getExportErrorCallback().onResult("Arbitrary error"); });
}
/**
* Requests showing an arbitrary password export error with a particular positive button to be
* shown. If you don't care about the button, just call {@link #requestShowingExportError}.
* @param preferences is the SavePasswordsPreferences instance being tested.
* @param positiveButtonLabelId controls which label the positive button ends up having.
*/
private void requestShowingExportErrorWithButton(
Preferences preferences, int positiveButtonLabelId) {
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences fragment =
(SavePasswordsPreferences) preferences.getMainFragment();
// To show an error, the error type for UMA needs to be specified. Because it is not
// relevant for cases when the error is forcibly displayed in tests,
// HistogramExportResult.NO_CONSUMER is passed as an arbitrarily chosen value.
fragment.getExportFlowForTesting().showExportErrorAndAbort(
R.string.save_password_preferences_export_no_app, null, positiveButtonLabelId,
ExportFlow.HistogramExportResult.NO_CONSUMER);
});
}
/**
* Sends the signal to {@link DialogManager} that the minimal time for showing the progress
* bar has passed. This results in the progress bar getting hidden as soon as requested.
*/
private void allowProgressBarToBeHidden(Preferences preferences) {
TestThreadUtils.runOnUiThreadBlocking(mManualDelayer::runCallbacksSynchronously);
}
/**
* Call after activity.finish() to wait for the wrap up to complete. If it was already completed
* or could be finished within |timeout_ms|, stop waiting anyways.
* @param activity The activity to wait for.
* @param timeout The timeout in ms after which the waiting will end anyways.
* @throws InterruptedException
*/
private void waitToFinish(Activity activity, long timeout) throws InterruptedException {
long start_time = System.currentTimeMillis();
while (activity.isFinishing() && (System.currentTimeMillis() - start_time < timeout))
Thread.sleep(100);
}
/**
* Create a temporary file in the cache sub-directory for exported passwords, which the test can
* try to use for sharing.
* @return The {@link File} handle for such temporary file.
*/
private File createFakeExportedPasswordsFile() throws IOException {
File passwordsDir = new File(ExportFlow.getTargetDirectory());
// Ensure that the directory exists.
passwordsDir.mkdir();
return File.createTempFile("test", ".csv", passwordsDir);
}
/**
* Ensure that resetting of empty passwords list works.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testResetListEmpty() throws Exception {
// Load the preferences, they should show the empty list.
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences savePasswordPreferences =
(SavePasswordsPreferences) preferences.getMainFragment();
// Emulate an update from PasswordStore. This should not crash.
savePasswordPreferences.passwordListAvailable(0);
});
}
/**
* Ensure that the on/off switch in "Save Passwords" settings actually enables and disables
* password saving.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSavePasswordsSwitch() throws Exception {
TestThreadUtils.runOnUiThreadBlocking(
() -> { PrefServiceBridge.getInstance().setRememberPasswordsEnabled(true); });
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
ChromeSwitchPreference onOffSwitch =
(ChromeSwitchPreference) savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_SAVE_PASSWORDS_SWITCH);
Assert.assertTrue(onOffSwitch.isChecked());
onOffSwitch.performClick();
Assert.assertFalse(PrefServiceBridge.getInstance().isRememberPasswordsEnabled());
onOffSwitch.performClick();
Assert.assertTrue(PrefServiceBridge.getInstance().isRememberPasswordsEnabled());
preferences.finish();
PrefServiceBridge.getInstance().setRememberPasswordsEnabled(false);
});
final Preferences preferences2 =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences2.getMainFragment();
ChromeSwitchPreference onOffSwitch =
(ChromeSwitchPreference) savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_SAVE_PASSWORDS_SWITCH);
Assert.assertFalse(onOffSwitch.isChecked());
});
}
/**
* Tests that the link pointing to managing passwords in the user's account is not displayed
* for non signed in users.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testManageAccountLinkNotSignedIn() throws Exception {
// Add a password entry, because the link is only displayed if the password list is not
// empty.
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
Assert.assertNull(savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_KEY_MANAGE_ACCOUNT_LINK));
}
/**
* Tests that the link pointing to managing passwords in the user's account is not displayed
* for signed in users, not syncing passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testManageAccountLinkSignedInNotSyncing() throws Exception {
// Add a password entry, because the link is only displayed if the password list is not
// empty.
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ChromeSigninController.get().setSignedInAccountName("Test Account");
overrideProfileSyncService(false, false);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
Assert.assertNull(savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_KEY_MANAGE_ACCOUNT_LINK));
}
/**
* Tests that the link pointing to managing passwords in the user's account is displayed for
* users syncing passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testManageAccountLinkSyncing() throws Exception {
// Add a password entry, because the link is only displayed if the password list is not
// empty.
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ChromeSigninController.get().setSignedInAccountName("Test Account");
overrideProfileSyncService(false, true);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
Assert.assertNotNull(savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_KEY_MANAGE_ACCOUNT_LINK));
}
/**
* Tests that the link pointing to managing passwords in the user's account is not displayed
* for users syncing passwords with custom passphrase.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testManageAccountLinkSyncingWithPassphrase() throws Exception {
// Add a password entry, because the link is only displayed if the password list is not
// empty.
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ChromeSigninController.get().setSignedInAccountName("Test Account");
overrideProfileSyncService(true, true);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
SavePasswordsPreferences savedPasswordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
Assert.assertNull(savedPasswordPrefs.findPreference(
SavePasswordsPreferences.PREF_KEY_MANAGE_ACCOUNT_LINK));
}
/**
* Ensure that the "Auto Sign-in" switch in "Save Passwords" settings actually enables and
* disables auto sign-in.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testAutoSignInCheckbox() throws Exception {
TestThreadUtils.runOnUiThreadBlocking(() -> {
PrefServiceBridge.getInstance().setPasswordManagerAutoSigninEnabled(true);
});
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences passwordPrefs =
(SavePasswordsPreferences) preferences.getMainFragment();
ChromeBaseCheckBoxPreference onOffSwitch =
(ChromeBaseCheckBoxPreference) passwordPrefs.findPreference(
SavePasswordsPreferences.PREF_AUTOSIGNIN_SWITCH);
Assert.assertTrue(onOffSwitch.isChecked());
onOffSwitch.performClick();
Assert.assertFalse(
PrefServiceBridge.getInstance().isPasswordManagerAutoSigninEnabled());
onOffSwitch.performClick();
Assert.assertTrue(PrefServiceBridge.getInstance().isPasswordManagerAutoSigninEnabled());
preferences.finish();
PrefServiceBridge.getInstance().setPasswordManagerAutoSigninEnabled(false);
});
final Preferences preferences2 =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
TestThreadUtils.runOnUiThreadBlocking(() -> {
SavePasswordsPreferences passwordPrefs =
(SavePasswordsPreferences) preferences2.getMainFragment();
ChromeBaseCheckBoxPreference onOffSwitch =
(ChromeBaseCheckBoxPreference) passwordPrefs.findPreference(
SavePasswordsPreferences.PREF_AUTOSIGNIN_SWITCH);
Assert.assertFalse(onOffSwitch.isChecked());
});
}
/**
* Check that the password data shown in the password editing activity matches the data of the
* password that was clicked.
*/
@Test
@SmallTest
@Feature({"Preferences"})
@Features.EnableFeatures(ChromeFeatureList.PASSWORD_EDITING_ANDROID)
public void testSelectedStoredPasswordDataIsSameAsEditedPasswordData() throws Exception {
setPasswordSourceWithMultipleEntries( // Initialize preferences
new SavedPasswordEntry[] {new SavedPasswordEntry("https://example.com",
"example user", "example password"),
new SavedPasswordEntry("https://test.com", "test user", "test password")});
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(withText(containsString("test user"))).perform(click());
Espresso.onView(withEditMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.site_edit)).check(matches(withText("https://test.com")));
}
/**
* Check that the changes of password data in the password editing activity are preserved and
* shown in the password viewing activity and in the list of passwords after the save button
* was clicked.
*/
@Test
@SmallTest
@Feature({"Preferences"})
@Features.EnableFeatures(ChromeFeatureList.PASSWORD_EDITING_ANDROID)
public void testChangeOfStoredPasswordDataIsPreserved() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(withText(containsString("test user"))).perform(click());
Espresso.onView(withEditMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.username_edit)).perform(typeText(" new"));
Espresso.onView(withSaveMenuIdOrText()).perform(click());
// Check if the password viewing activity has the updated data.
Espresso.onView(withText("test user new")).check(matches(isDisplayed()));
Espresso.pressBack();
// Check if the password preferences activity has the updated data in the list of passwords.
Espresso.onView(withText("test user new")).check(matches(isDisplayed()));
}
/**
* Check that if there are no saved passwords, the export menu item is disabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuDisabled() throws Exception {
// Ensure there are no saved passwords reported to settings.
setPasswordSource(null);
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
checkExportMenuItemState(MenuItemState.DISABLED);
}
/**
* Check that if there are saved passwords, the export menu item is enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuEnabled() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that tapping the export menu requests the passwords to be serialised in the background.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportTriggersSerialization() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
// Before tapping the menu item for export, pretend that the last successful
// reauthentication just happened. This will allow the export flow to continue.
ReauthenticationManager.recordLastReauth(
System.currentTimeMillis(), ReauthenticationManager.ReauthScope.BULK);
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
Assert.assertNotNull(mHandler.getExportTargetPath());
Assert.assertFalse(mHandler.getExportTargetPath().isEmpty());
}
/**
* Check that the export menu item is included and hidden behind the overflow menu. Check that
* the menu displays the warning before letting the user export passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuItem() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Check that the warning dialog is displayed.
Espresso.onView(withText(R.string.settings_passwords_export_description))
.check(matches(isDisplayed()));
}
/**
* Check that if export is canceled by the user after a successful reauthentication, then
* re-triggering the export and failing the second reauthentication aborts the export as well.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportReauthAfterCancel() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Hit the Cancel button on the warning dialog to cancel the flow.
Espresso.onView(withText(R.string.cancel)).perform(click());
// Now repeat the steps almost like in |reauthenticateAndRequestExport| but simulate failing
// the reauthentication challenge.
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
// Avoid launching the Android-provided reauthentication challenge, which cannot be
// completed in the test.
ReauthenticationManager.setSkipSystemReauth(true);
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Now Chrome thinks it triggered the challenge and is waiting to be resumed. Once resumed
// it will check the reauthentication result. First, update the reauth timestamp to indicate
// a cancelled reauth:
ReauthenticationManager.resetLastReauth();
// Now call onResume to nudge Chrome into continuing the export flow.
TestThreadUtils.runOnUiThreadBlocking(() -> { preferences.getMainFragment().onResume(); });
// Check that the warning dialog is not displayed.
Espresso.onView(withText(R.string.settings_passwords_export_description))
.check(doesNotExist());
// Check that the export menu item is enabled, because the current export was cancelled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check whether the user is asked to set up a screen lock if attempting to export passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuItemNoLock() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.UNAVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
View mainDecorView = preferences.getWindow().getDecorView();
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
Espresso.onView(withText(R.string.password_export_set_lock_screen))
.inRoot(withDecorView(not(is(mainDecorView))))
.check(matches(isDisplayed()));
}
/**
* Check that if exporting is cancelled for the absence of the screen lock, the menu item is
* enabled for a retry.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuItemReenabledNoLock() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.UNAVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Trigger exporting and let it fail on the unavailable lock.
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Check that for re-triggering, the export menu item is enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that if exporting is cancelled for the user's failure to reauthenticate, the menu item
* is enabled for a retry.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportMenuItemReenabledReauthFailure() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setSkipSystemReauth(true);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// The reauthentication dialog is skipped and the last reauthentication timestamp is not
// reset. This looks like a failed reauthentication to SavePasswordsPreferences' onResume.
TestThreadUtils.runOnUiThreadBlocking(() -> { preferences.getMainFragment().onResume(); });
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the export always requires a reauthentication, even if the last one happened
* recently.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportRequiresReauth() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Ensure that the last reauthentication time stamp is recent enough.
ReauthenticationManager.recordLastReauth(
System.currentTimeMillis(), ReauthenticationManager.ReauthScope.BULK);
// Start export.
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
// Avoid launching the Android-provided reauthentication challenge, which cannot be
// completed in the test.
ReauthenticationManager.setSkipSystemReauth(true);
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Check that Chrome indeed issued an (ignored) request to reauthenticate the user rather
// than re-using the recent reauthentication, by observing that the next step in the flow
// (progress bar) is not shown.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(doesNotExist());
}
/**
* Check that the export flow ends up with sending off a share intent with the exported
* passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportIntent() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Intents.init();
reauthenticateAndRequestExport(preferences);
File tempFile = createFakeExportedPasswordsFile();
// Pretend that passwords have been serialized to go directly to the intent.
mHandler.getExportSuccessCallback().onResult(123, tempFile.getPath());
// Before triggering the sharing intent chooser, stub it out to avoid leaving system UI open
// after the test is finished.
intending(hasAction(equalTo(Intent.ACTION_CHOOSER)))
.respondWith(new Instrumentation.ActivityResult(Activity.RESULT_OK, null));
// Confirm the export warning to fire the sharing intent.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
intended(allOf(hasAction(equalTo(Intent.ACTION_CHOOSER)),
hasExtras(hasEntry(equalTo(Intent.EXTRA_INTENT),
allOf(hasAction(equalTo(Intent.ACTION_SEND)), hasType("text/csv"))))));
Intents.release();
tempFile.delete();
}
/**
* Check that the export flow ends up with sending off a share intent with the exported
* passwords, even if the flow gets interrupted by pausing Chrome.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportIntentPaused() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Intents.init();
reauthenticateAndRequestExport(preferences);
// Call onResume to simulate that the user put Chrome into background by opening "recent
// apps" and then restored Chrome by choosing it from the list.
TestThreadUtils.runOnUiThreadBlocking(() -> { preferences.getMainFragment().onResume(); });
File tempFile = createFakeExportedPasswordsFile();
// Pretend that passwords have been serialized to go directly to the intent.
mHandler.getExportSuccessCallback().onResult(56, tempFile.getPath());
// Before triggering the sharing intent chooser, stub it out to avoid leaving system UI open
// after the test is finished.
intending(hasAction(equalTo(Intent.ACTION_CHOOSER)))
.respondWith(new Instrumentation.ActivityResult(Activity.RESULT_OK, null));
// Confirm the export warning to fire the sharing intent.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
intended(allOf(hasAction(equalTo(Intent.ACTION_CHOOSER)),
hasExtras(hasEntry(equalTo(Intent.EXTRA_INTENT),
allOf(hasAction(equalTo(Intent.ACTION_SEND)), hasType("text/csv"))))));
Intents.release();
tempFile.delete();
}
/**
* Check that the export flow can be canceled in the warning dialogue and that upon cancellation
* the export menu item gets re-enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportCancelOnWarning() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Cancel the export warning.
Espresso.onView(withText(R.string.cancel)).perform(click());
// Check that the cancellation succeeded by checking that the export menu is available and
// enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the export warning is not duplicated when onResume is called on the settings.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportWarningOnResume() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Call onResume to simulate that the user put Chrome into background by opening "recent
// apps" and then restored Chrome by choosing it from the list.
TestThreadUtils.runOnUiThreadBlocking(() -> { preferences.getMainFragment().onResume(); });
// Cancel the export warning.
Espresso.onView(withText(R.string.cancel)).perform(click());
// Check that export warning is not visible again.
Espresso.onView(withText(R.string.cancel)).check(doesNotExist());
// Check that the cancellation succeeded by checking that the export menu is available and
// enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the export warning is dismissed after onResume if the last reauthentication
* happened too long ago.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportWarningTimeoutOnResume() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
// Before exporting, pretend that the last successful reauthentication happend too long ago.
ReauthenticationManager.recordLastReauth(System.currentTimeMillis()
- ReauthenticationManager.VALID_REAUTHENTICATION_TIME_INTERVAL_MILLIS - 1,
ReauthenticationManager.ReauthScope.BULK);
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Call onResume to simulate that the user put Chrome into background by opening "recent
// apps" and then restored Chrome by choosing it from the list.
TestThreadUtils.runOnUiThreadBlocking(() -> { preferences.getMainFragment().onResume(); });
// Check that export warning is not visible again.
Espresso.onView(withText(R.string.cancel)).check(doesNotExist());
// Check that the export flow was cancelled automatically by checking that the export menu
// is available and enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the export flow can be canceled by dismissing the warning dialogue (tapping
* outside of it, as opposed to tapping "Cancel") and that upon cancellation the export menu
* item gets re-enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportCancelOnWarningDismissal() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Verify that the warning dialog is shown and then dismiss it through pressing back (as
// opposed to the cancel button).
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.check(matches(isDisplayed()));
Espresso.pressBack();
// Check that the cancellation succeeded by checking that the export menu is available and
// enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that a progressbar is displayed for a minimal time duration to avoid flickering.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportProgressMinimalTime() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Intents.init();
// This also disables the timer for keeping the progress bar up. The test can thus emulate
// that timer going off by calling {@link allowProgressBarToBeHidden}.
reauthenticateAndRequestExport(preferences);
// Before triggering the sharing intent chooser, stub it out to avoid leaving system UI open
// after the test is finished.
intending(hasAction(equalTo(Intent.ACTION_CHOOSER)))
.respondWith(new Instrumentation.ActivityResult(Activity.RESULT_OK, null));
// Confirm the export warning to fire the sharing intent.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Before simulating the serialized passwords being received, check that the progress bar is
// shown.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(matches(isDisplayed()));
File tempFile = createFakeExportedPasswordsFile();
// Now pretend that passwords have been serialized.
mHandler.getExportSuccessCallback().onResult(12, tempFile.getPath());
// Check that the progress bar is still shown, though, because the timer has not gone off
// yet.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(matches(isDisplayed()));
// Now mark the timer as gone off and check that the progress bar is hidden.
allowProgressBarToBeHidden(preferences);
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(doesNotExist());
intended(allOf(hasAction(equalTo(Intent.ACTION_CHOOSER)),
hasExtras(hasEntry(equalTo(Intent.EXTRA_INTENT),
allOf(hasAction(equalTo(Intent.ACTION_SEND)), hasType("text/csv"))))));
Intents.release();
tempFile.delete();
}
/**
* Check that a progressbar is displayed when the user confirms the export and the serialized
* passwords are not ready yet.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportProgress() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Intents.init();
reauthenticateAndRequestExport(preferences);
// Before triggering the sharing intent chooser, stub it out to avoid leaving system UI open
// after the test is finished.
intending(hasAction(equalTo(Intent.ACTION_CHOOSER)))
.respondWith(new Instrumentation.ActivityResult(Activity.RESULT_OK, null));
// Confirm the export warning to fire the sharing intent.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Before simulating the serialized passwords being received, check that the progress bar is
// shown.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(matches(isDisplayed()));
File tempFile = createFakeExportedPasswordsFile();
// Now pretend that passwords have been serialized.
allowProgressBarToBeHidden(preferences);
mHandler.getExportSuccessCallback().onResult(12, tempFile.getPath());
// After simulating the serialized passwords being received, check that the progress bar is
// hidden.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(doesNotExist());
intended(allOf(hasAction(equalTo(Intent.ACTION_CHOOSER)),
hasExtras(hasEntry(equalTo(Intent.EXTRA_INTENT),
allOf(hasAction(equalTo(Intent.ACTION_SEND)), hasType("text/csv"))))));
Intents.release();
tempFile.delete();
}
/**
* Check that the user can cancel exporting with the "Cancel" button on the progressbar.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportCancelOnProgress() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Confirm the export warning to fire the sharing intent.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Simulate the minimal time for showing the progress bar to have passed, to ensure that it
// is kept live because of the pending serialization.
allowProgressBarToBeHidden(preferences);
// Check that the progress bar is shown.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(matches(isDisplayed()));
// Hit the Cancel button.
Espresso.onView(withText(R.string.cancel)).perform(click());
// Check that the cancellation succeeded by checking that the export menu is available and
// enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the user can cancel exporting with the negative button on the error message.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportCancelOnError() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Confirm the export warning.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Show an arbitrary error. This should replace the progress bar if that has been shown in
// the meantime.
allowProgressBarToBeHidden(preferences);
requestShowingExportError();
// Check that the error prompt is showing.
Espresso.onView(withText(R.string.save_password_preferences_export_error_title))
.check(matches(isDisplayed()));
// Hit the negative button on the error prompt.
Espresso.onView(withText(R.string.close)).perform(click());
// Check that the cancellation succeeded by checking that the export menu is available and
// enabled.
checkExportMenuItemState(MenuItemState.ENABLED);
}
/**
* Check that the user can re-trigger the export from an error dialog which has a "retry"
* button.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportRetry() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Confirm the export warning.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Show an arbitrary error but ensure that the positive button label is the one for "try
// again".
allowProgressBarToBeHidden(preferences);
requestShowingExportErrorWithButton(preferences, R.string.try_again);
// Hit the positive button to try again.
Espresso.onView(withText(R.string.try_again)).perform(click());
// Check that there is again the export warning.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.check(matches(isDisplayed()));
}
/**
* Check that the error dialog lets the user visit a help page to install Google Drive if they
* need an app to consume the exported passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportHelpSite() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Confirm the export warning.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Show an arbitrary error but ensure that the positive button label is the one for the
// Google Drive help site.
allowProgressBarToBeHidden(preferences);
requestShowingExportErrorWithButton(
preferences, R.string.save_password_preferences_export_learn_google_drive);
Intents.init();
// Before triggering the viewing intent, stub it out to avoid cascading that into further
// intents and opening the web browser.
intending(hasAction(equalTo(Intent.ACTION_VIEW)))
.respondWith(new Instrumentation.ActivityResult(Activity.RESULT_OK, null));
// Hit the positive button to navigate to the help site.
Espresso.onView(withText(R.string.save_password_preferences_export_learn_google_drive))
.perform(click());
intended(allOf(hasAction(equalTo(Intent.ACTION_VIEW)),
hasData(hasHost(equalTo("support.google.com")))));
Intents.release();
}
/**
* Check that if errors are encountered when user is busy confirming the export, the error UI is
* shown after the confirmation is completed, so that the user does not see UI changing
* unexpectedly under their fingers.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testExportErrorUiAfterConfirmation() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
reauthenticateAndRequestExport(preferences);
// Request showing an arbitrary error while the confirmation dialog is still up.
requestShowingExportError();
// Check that the confirmation dialog is showing and dismiss it.
Espresso.onView(withText(R.string.save_password_preferences_export_action_title))
.perform(click());
// Check that now the error is displayed, instead of the progress bar.
allowProgressBarToBeHidden(preferences);
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(doesNotExist());
Espresso.onView(withText(R.string.save_password_preferences_export_error_title))
.check(matches(isDisplayed()));
// Close the error dialog and abort the export.
Espresso.onView(withText(R.string.close)).perform(click());
// Ensure that there is still no progress bar.
Espresso.onView(withText(R.string.settings_passwords_preparing_export))
.check(doesNotExist());
}
/**
* Check whether the user is asked to set up a screen lock if attempting to view passwords.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testViewPasswordNoLock() throws Exception {
setPasswordSource(new SavedPasswordEntry("https://example.com", "test user", "password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.UNAVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
View mainDecorView = preferences.getWindow().getDecorView();
Espresso.onView(withText(containsString("test user"))).perform(click());
Espresso.onView(withContentDescription(R.string.password_entry_viewer_copy_stored_password))
.perform(click());
Espresso.onView(withText(R.string.password_entry_viewer_set_lock_screen))
.inRoot(withDecorView(not(is(mainDecorView))))
.check(matches(isDisplayed()));
}
/**
* Check whether the user can view a saved password.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testViewPassword() throws Exception {
setPasswordSource(
new SavedPasswordEntry("https://example.com", "test user", "test password"));
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
final Preferences preferences =
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(withText(containsString("test user"))).perform(click());
// Before tapping the view button, pretend that the last successful reauthentication just
// happened. This will allow showing the password.
ReauthenticationManager.recordLastReauth(
System.currentTimeMillis(), ReauthenticationManager.ReauthScope.ONE_AT_A_TIME);
Espresso.onView(withContentDescription(R.string.password_entry_viewer_view_stored_password))
.perform(click());
Espresso.onView(withText("test password")).check(matches(isDisplayed()));
}
/**
* Check that the search item is visible if the Feature is enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
@SuppressWarnings("AlwaysShowAction") // We need to ensure the icon is in the action bar.
public void testSearchIconVisibleInActionBarWithFeature() throws Exception {
setPasswordSource(null); // Initialize empty preferences.
SavePasswordsPreferences f =
(SavePasswordsPreferences) PreferencesTest
.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName())
.getMainFragment();
// Force the search option into the action bar.
TestThreadUtils.runOnUiThreadBlocking(
()
-> f.getMenuForTesting()
.findItem(R.id.menu_id_search)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS));
Espresso.onView(withId(R.id.menu_id_search)).check(matches(isDisplayed()));
}
/**
* Check that the icon for editing saved passwords is visible if the Feature is enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
@Features.EnableFeatures(ChromeFeatureList.PASSWORD_EDITING_ANDROID)
public void testEditSavedPasswordIconVisibleInActionBarWithFeature() throws Exception {
setPasswordSource( // Initialize preferences
new SavedPasswordEntry("https://example.com", "test user", "test password"));
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(withText(containsString("test user"))).perform(click());
Espresso.onView(withEditMenuIdOrText()).check(matches(isDisplayed()));
}
/**
* Check that the search item is visible if the Feature is enabled.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchTextInOverflowMenuVisibleWithFeature() throws Exception {
setPasswordSource(null); // Initialize empty preferences.
SavePasswordsPreferences f =
(SavePasswordsPreferences) PreferencesTest
.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName())
.getMainFragment();
// Force the search option into the overflow menu.
TestThreadUtils.runOnUiThreadBlocking(
()
-> f.getMenuForTesting()
.findItem(R.id.menu_id_search)
.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER));
// Open the overflow menu.
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.search)).check(matches(isDisplayed()));
}
/**
* Check that searching doesn't push the help icon into the overflow menu permanently.
* On screen sizes where the help item starts out in the overflow menu, ensure it stays there.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testTriggeringSearchRestoresHelpIcon() throws Exception {
setPasswordSource(null);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView(
(ViewGroup) root, withText(R.string.prefs_saved_passwords_title)));
// Retrieve the initial status and ensure that the help option is there at all.
final AtomicReference<Boolean> helpInOverflowMenu = new AtomicReference<>(false);
Espresso.onView(withId(R.id.menu_id_general_help)).check((helpMenuItem, e) -> {
ActionMenuItemView view = (ActionMenuItemView) helpMenuItem;
helpInOverflowMenu.set(view == null || !view.showsIcon());
});
if (helpInOverflowMenu.get()) {
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.menu_help)).check(matches(isDisplayed()));
Espresso.pressBack(); // to close the Overflow menu.
} else {
Espresso.onView(withId(R.id.menu_id_general_help)).check(matches(isDisplayed()));
}
// Trigger the search, close it and wait for UI to be restored.
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withContentDescription(R.string.abc_action_bar_up_description))
.perform(click());
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView(
(ViewGroup) root, withText(R.string.prefs_saved_passwords_title)));
// Check that the help option is exactly where it was to begin with.
if (helpInOverflowMenu.get()) {
openActionBarOverflowOrOptionsMenu(
InstrumentationRegistry.getInstrumentation().getTargetContext());
Espresso.onView(withText(R.string.menu_help)).check(matches(isDisplayed()));
Espresso.onView(withId(R.id.menu_id_general_help)).check(doesNotExist());
} else {
Espresso.onView(withText(R.string.menu_help)).check(doesNotExist());
Espresso.onView(withId(R.id.menu_id_general_help)).check(matches(isDisplayed()));
}
}
/**
* Check that the search filters the list by name.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchFiltersByUserName() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Search for a string matching multiple user names. Case doesn't need to match.
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.search_src_text))
.perform(click(), typeText("aREs"), closeSoftKeyboard());
Espresso.onView(withText(ARES_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(PHOBOS_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(DEIMOS_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(ZEUS_ON_EARTH.getUserName())).check(doesNotExist());
Espresso.onView(withText(HADES_AT_UNDERWORLD.getUrl())).check(doesNotExist());
}
/**
* Check that the search filters the list by URL.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchFiltersByUrl() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Search for a string that matches multiple URLs. Case doesn't need to match.
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.search_src_text))
.perform(click(), typeText("Olymp"), closeSoftKeyboard());
Espresso.onView(withText(ARES_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(PHOBOS_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(DEIMOS_AT_OLYMP.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(ZEUS_ON_EARTH.getUserName())).check(doesNotExist());
Espresso.onView(withText(HADES_AT_UNDERWORLD.getUrl())).check(doesNotExist());
}
/**
* Check that the search filters the list by URL.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchDisplaysBlankPageIfSearchTurnsUpEmpty() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Open the search which should hide the Account link.
Espresso.onView(withSearchMenuIdOrText()).perform(click());
// Search for a string that matches nothing which should leave the results entirely blank.
Espresso.onView(withId(R.id.search_src_text))
.perform(click(), typeText("Mars"), closeSoftKeyboard());
for (SavedPasswordEntry god : GREEK_GODS) {
Espresso.onView(allOf(withText(god.getUserName()), withText(god.getUrl())))
.check(doesNotExist());
}
Espresso.onView(withText(R.string.saved_passwords_none_text)).check(doesNotExist());
// Check that the section header for saved passwords is not present. Do not confuse it with
// the toolbar label which contains the same string, look for the one inside a linear
// layout.
Espresso.onView(allOf(withParent(isAssignableFrom(LinearLayout.class)),
withText(R.string.prefs_saved_passwords_title)))
.check(doesNotExist());
}
/**
* Check that triggering the search hides all non-password prefs.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchIconClickedHidesExceptionsTemporarily() throws Exception {
setPasswordExceptions(new String[] {"http://exclu.de", "http://not-inclu.de"});
final SavePasswordsPreferences savePasswordPreferences =
(SavePasswordsPreferences) PreferencesTest
.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName())
.getMainFragment();
Espresso.onView(withText(R.string.section_saved_passwords_exceptions))
.check(matches(isDisplayed()));
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.search_src_text)).perform(click(), closeSoftKeyboard());
Espresso.onView(withText(R.string.section_saved_passwords_exceptions))
.check(doesNotExist());
Espresso.onView(withContentDescription(R.string.abc_action_bar_up_description))
.perform(click());
InstrumentationRegistry.getInstrumentation().waitForIdleSync(); // Close search view.
Espresso.onView(withText(R.string.section_saved_passwords_exceptions))
.check(matches(isDisplayed()));
}
/**
* Check that triggering the search hides all non-password prefs.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchIconClickedHidesGeneralPrefs() throws Exception {
setPasswordSource(ZEUS_ON_EARTH);
final SavePasswordsPreferences prefs =
(SavePasswordsPreferences) PreferencesTest
.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName())
.getMainFragment();
final AtomicReference<Boolean> menuInitiallyVisible = new AtomicReference<>();
TestThreadUtils.runOnUiThreadBlocking(
()
-> menuInitiallyVisible.set(
prefs.getToolbarForTesting().isOverflowMenuShowing()));
Espresso.onView(withText(R.string.passwords_auto_signin_title))
.check(matches(isDisplayed()));
if (menuInitiallyVisible.get()) { // Check overflow menu only on large screens that have it.
Espresso.onView(withContentDescription(R.string.abc_action_menu_overflow_description))
.check(matches(isDisplayed()));
}
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withText(R.string.passwords_auto_signin_title)).check(doesNotExist());
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView((ViewGroup) root,
withParent(withContentDescription(
R.string.abc_action_menu_overflow_description)),
VIEW_INVISIBLE | VIEW_GONE | VIEW_NULL));
Espresso.onView(withContentDescription(R.string.abc_action_bar_up_description))
.perform(click());
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
if (menuInitiallyVisible.get()) { // If the overflow menu was there, it should be restored.
Espresso.onView(withContentDescription(R.string.abc_action_menu_overflow_description))
.check(matches(isDisplayed()));
}
}
/**
* Check that closing the search via back button brings back all non-password prefs.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchBarBackButtonRestoresGeneralPrefs() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(withId(R.id.search_src_text))
.perform(click(), typeText("Zeu"), closeSoftKeyboard());
Espresso.onView(withText(R.string.passwords_auto_signin_title)).check(doesNotExist());
Espresso.onView(withContentDescription(R.string.abc_action_bar_up_description))
.perform(click());
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
Espresso.onView(withText(R.string.passwords_auto_signin_title))
.check(matches(isDisplayed()));
Espresso.onView(withId(R.id.menu_id_search)).check(matches(isDisplayed()));
}
/**
* Check that clearing the search also hides the clear button.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchViewCloseIconExistsOnlyToClearQueries() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Trigger search which shouldn't have the button yet.
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView((ViewGroup) root, withId(R.id.search_close_btn),
VIEW_INVISIBLE | VIEW_GONE | VIEW_NULL));
// Type something and see the button appear.
Espresso.onView(withId(R.id.search_src_text))
// Trigger search which shouldn't have the button yet.
.perform(click(), typeText("Zeu"), closeSoftKeyboard());
Espresso.onView(withId(R.id.search_close_btn)).check(matches(isDisplayed()));
// Clear the search which should hide the button again.
Espresso.onView(withId(R.id.search_close_btn)).perform(click()); // Clear search.
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView((ViewGroup) root, withId(R.id.search_close_btn),
VIEW_INVISIBLE | VIEW_GONE | VIEW_NULL));
}
/**
* Check that the changed color of the loaded Drawable does not persist for other uses of the
* drawable. This is not implicitly true as a loaded Drawable is by default only a reference to
* the globally defined resource.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchIconColorAffectsOnlyLocalSearchDrawable() throws Exception {
// Open the password preferences and remember the applied color filter.
final SavePasswordsPreferences f =
(SavePasswordsPreferences) PreferencesTest
.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName())
.getMainFragment();
Espresso.onView(withId(R.id.search_button)).check(matches(isDisplayed()));
final AtomicReference<ColorFilter> passwordSearchFilter = new AtomicReference<>();
TestThreadUtils.runOnUiThreadBlocking(() -> {
Drawable drawable = f.getMenuForTesting().findItem(R.id.menu_id_search).getIcon();
passwordSearchFilter.set(DrawableCompat.getColorFilter(drawable));
});
// Now launch a non-empty History activity.
StubbedHistoryProvider mHistoryProvider = new StubbedHistoryProvider();
mHistoryProvider.addItem(StubbedHistoryProvider.createHistoryItem(0, new Date().getTime()));
mHistoryProvider.addItem(StubbedHistoryProvider.createHistoryItem(1, new Date().getTime()));
HistoryManager.setProviderForTests(mHistoryProvider);
mHistoryActivityTestRule.launchActivity(null);
// Find the search view to ensure that the set color filter is different from the saved one.
final AtomicReference<ColorFilter> historySearchFilter = new AtomicReference<>();
Espresso.onView(withId(R.id.search_menu_id)).check(matches(isDisplayed()));
Espresso.onView(withId(R.id.search_menu_id)).check((searchMenuItem, e) -> {
Drawable drawable = ((ActionMenuItemView) searchMenuItem).getItemData().getIcon();
historySearchFilter.set(DrawableCompat.getColorFilter(drawable));
Assert.assertThat(historySearchFilter.get(),
anyOf(is(nullValue()), is(not(sameInstance(passwordSearchFilter.get())))));
});
// Close the activity and check that the icon in the password preferences has not changed.
mHistoryActivityTestRule.getActivity().finish();
TestThreadUtils.runOnUiThreadBlocking(() -> {
ColorFilter colorFilter = DrawableCompat.getColorFilter(
f.getMenuForTesting().findItem(R.id.menu_id_search).getIcon());
Assert.assertThat(colorFilter,
anyOf(is(nullValue()), is(sameInstance(passwordSearchFilter.get()))));
Assert.assertThat(colorFilter,
anyOf(is(nullValue()), is(not(sameInstance(historySearchFilter.get())))));
});
}
/**
* Check that the filtered password list persists after the user had inspected a single result.
*/
@Test
@SmallTest
@Feature({"Preferences"})
public void testSearchResultsPersistAfterEntryInspection() throws Exception {
setPasswordSourceWithMultipleEntries(GREEK_GODS);
setPasswordExceptions(new String[] {"http://exclu.de", "http://not-inclu.de"});
ReauthenticationManager.setApiOverride(ReauthenticationManager.OverrideState.AVAILABLE);
ReauthenticationManager.setScreenLockSetUpOverride(
ReauthenticationManager.OverrideState.AVAILABLE);
PreferencesTest.startPreferences(InstrumentationRegistry.getInstrumentation(),
SavePasswordsPreferences.class.getName());
// Open the search and filter all but "Zeus".
Espresso.onView(withSearchMenuIdOrText()).perform(click());
Espresso.onView(isRoot()).check(
(root, e) -> waitForView((ViewGroup) root, withId(R.id.search_src_text)));
Espresso.onView(withId(R.id.search_src_text))
.perform(click(), typeText("Zeu"), closeSoftKeyboard());
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
Espresso.onView(withText(R.string.passwords_auto_signin_title)).check(doesNotExist());
Espresso.onView(withText(ZEUS_ON_EARTH.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(PHOBOS_AT_OLYMP.getUserName())).check(doesNotExist());
Espresso.onView(withText(HADES_AT_UNDERWORLD.getUrl())).check(doesNotExist());
// Click "Zeus" to open edit field and verify the password. Pretend the user just passed the
// reauthentication challenge.
ReauthenticationManager.recordLastReauth(
System.currentTimeMillis(), ReauthenticationManager.ReauthScope.ONE_AT_A_TIME);
Instrumentation.ActivityMonitor monitor =
InstrumentationRegistry.getInstrumentation().addMonitor(
new IntentFilter(Intent.ACTION_VIEW), null, false);
Espresso.onView(withText(ZEUS_ON_EARTH.getUserName())).perform(click());
monitor.waitForActivityWithTimeout(UI_UPDATING_TIMEOUT_MS);
Assert.assertEquals("Monitor for has not been called", 1, monitor.getHits());
InstrumentationRegistry.getInstrumentation().removeMonitor(monitor);
Espresso.onView(withContentDescription(R.string.password_entry_viewer_view_stored_password))
.perform(click());
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
Espresso.onView(withText(ZEUS_ON_EARTH.getPassword())).check(matches(isDisplayed()));
Espresso.onView(withContentDescription(R.string.abc_action_bar_up_description))
.perform(click()); // Go back to the search list.
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
Espresso.onView(withText(R.string.passwords_auto_signin_title)).check(doesNotExist());
Espresso.onView(withText(ZEUS_ON_EARTH.getUserName())).check(matches(isDisplayed()));
Espresso.onView(withText(PHOBOS_AT_OLYMP.getUserName())).check(doesNotExist());
Espresso.onView(withText(HADES_AT_UNDERWORLD.getUrl())).check(doesNotExist());
InstrumentationRegistry.getInstrumentation().waitForIdleSync();
// The search bar should still be open and still display the search query.
Espresso.onView(isRoot()).check(
(root, e)
-> waitForView((ViewGroup) root,
allOf(withId(R.id.search_src_text), withText("Zeu"))));
Espresso.onView(withId(R.id.search_src_text)).check(matches(withText("Zeu")));
}
}
| [
"[email protected]"
] | |
251f85baca6b44bcabf2cacad1f60f60e2385607 | 21a5e9d9a7cc088f1b23efb0e97d585e8da54a0e | /services/src/main/java/com/kientran/pms/otp_service/response_models/VerifyingOTPResponse.java | 132135d32fd63f9e222de7cbcf4de9a2f8f7419c | [] | no_license | ttkien/pms | 3dc3c616667c25f03b09c56c0bc9e3a2520ee35d | f9b7404b9bbf1cedd549155c245f3659c5529c11 | refs/heads/master | 2020-04-07T04:16:54.807431 | 2018-11-24T13:57:31 | 2018-11-24T13:57:31 | 158,048,540 | 0 | 0 | null | 2018-11-29T02:54:44 | 2018-11-18T04:06:02 | Java | UTF-8 | Java | false | false | 359 | java | package com.kientran.pms.otp_service.response_models;
public class VerifyingOTPResponse {
private Boolean isVerify;
public Boolean getVerify() {
return isVerify;
}
public void setVerify(Boolean verify) {
isVerify = verify;
}
public VerifyingOTPResponse(Boolean isVerify) {
this.isVerify = isVerify;
}
}
| [
"[email protected]"
] | |
c790b80574816ea26aac65bd4dc32878398ec78e | 3daf7dbf72c08c65e4e65878d5d963770d76e3e2 | /workspacesForChinese/数据库应用/src/com/example/dbproject/MainActivity.java | 4545a3667b8744cb71f5435a05f7d692b14d6ffa | [] | no_license | zj386018/zjandroid | 068a45cdd5d33741b3b545f735356e09d31c2e59 | d3f9d36013adfb26fd7118a1f45dea553af67c67 | refs/heads/master | 2021-01-21T12:53:34.097274 | 2016-05-24T09:09:56 | 2016-05-24T09:09:56 | 54,310,752 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 311 | java | package com.example.dbproject;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
| [
"[email protected]"
] | |
e738ca28b343709caf57c6fa57aac277d667801f | 321159f229edbf5d6c015ddeba22ae48ca98aaac | /src/day27_DateTime/Dates.java | 6d8df0a299cde845c3591e5f29bc6c92784ed2e4 | [] | no_license | store13/JavaB18 | 6a9f5ef0bfeba04df727bb69a95bae10aae874aa | e8a53f7fe6fff6c6b6c5d7b6d14cd1b597341e40 | refs/heads/master | 2022-08-04T20:11:23.174753 | 2020-05-15T20:34:01 | 2020-05-15T20:34:01 | 259,387,153 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,266 | java | package day27_DateTime;
import java.time.LocalDate;
public class Dates {
/*
LocalDate : used for creating date (year, months, days)
methods:
isAfter() :
isBefore() :
isEqual() :
isLeapYear():
toString
*/
public static void main(String[] args) {
LocalDate date1 = LocalDate.of(2020,10,25);
System.out.println(date1);
LocalDate birthday = LocalDate.of(2020, 12,25);
System.out.println(birthday);
// isAfter(date2)
boolean result1 = date1.isAfter(birthday);
System.out.println(result1);
// isBefore(date2)
boolean result2 = date1.isBefore(birthday);
System.out.println(result2);
// isEqual(date2)
boolean result3 = date1.isEqual(birthday);
System.out.println(result3);
// isLeapyear();
boolean result4 = birthday.isLeapYear();
System.out.println(result4);
System.out.println("=========================================================");
LocalDate now = LocalDate.now(); // 2020-04-23
System.out.println("Today is: "+now);
String str = now.toString();
System.out.println(str.replace("-", " "));
// month/day/year
}
}
| [
"[email protected]"
] | |
519e6c89b1ac57ea41edeb4e36687c6df71c6ed1 | b6a4947da81ff165d4f1739962a9845da4eefe1e | /Level15/Task1530/DrinkMaker.java | 86df7eecf1ccb66b3a11ab7cb996540cdeb6c76f | [] | no_license | SaniyaKaliyeva/JavaRush | c76ea01ca526174cb3f97a9f100531656753a52e | 9888d99db845f8156ddeb40c2637772f7e2dde6b | refs/heads/master | 2020-04-19T04:19:51.608909 | 2019-02-19T08:43:26 | 2019-02-19T08:43:26 | 153,742,142 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 471 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package Level15.Task1530;
/**
*
* @author macbookair
*/
abstract public class DrinkMaker {
abstract void getRightCup();
abstract void putIngredient();
abstract void pour();
void makeDrink(){
getRightCup();
putIngredient();
pour();
}
}
| [
"[email protected]"
] | |
8fef436c3af1a1e1378cdba3122b02e9d09d5be0 | e4173c19b86ad0ffa54f863a2be18f50e8bb82d1 | /代码/FileManagementSys/src/main/java/cn/com/sparknet/common/util/UUIDUtil.java | 9c48e75244844689fac2d9eab06f4077f6fa8327 | [] | no_license | gaomc110/FileManagementSys | 135a2c4ce6a05e09af1a2415338b11fc8979a44e | 660d9eefa2d6d31268b0d2ba68289b8009b5c21b | refs/heads/master | 2022-12-21T02:56:15.696048 | 2019-10-11T01:22:25 | 2019-10-11T01:22:25 | 214,307,710 | 0 | 0 | null | 2022-12-16T08:23:02 | 2019-10-11T00:07:29 | JavaScript | UTF-8 | Java | false | false | 786 | java | package cn.com.sparknet.common.util;
import java.util.Random;
import java.util.UUID;
/**
* UUID生成类(32位)
* @author chenxy
*
*/
public final class UUIDUtil {
private UUIDUtil(){
}
/**
* 获取字符ID
* @return
*/
public static final String getNextValue() {
String id=UUID.randomUUID().toString();
return id.replaceAll("-", "");
}
/**
* 获取数字ID
* @return
*/
public static final String getNextIntValue() {
int totalLength=32;
Random random=new Random();
StringBuffer num=new StringBuffer();
String time=String.valueOf(System.currentTimeMillis());
int timeLength=time.length();
int cycleLength=totalLength-timeLength;
for(int i=0;i<cycleLength;i++){
num.append(random.nextInt(10));
}
return time+num.toString();
}
}
| [
"[email protected]"
] | |
25cb41b6f05adcfd909e22415ff5a2fb7735026b | 73c99e64be10ba55ff441140ea995c9d4fdccea3 | /project2/src/FrontEndServerCache.java | 8674c901e5af6e9fa54898709312b50c862a58c3 | [] | no_license | josealvarado/CS682-StronglyConnectedTwitterService | 827cc06da88c1c10d76aba91bdc96c08f2f87cee | fecb3fc88650f390a08439dd62a758cf966d27a7 | refs/heads/master | 2020-06-06T08:26:34.097667 | 2014-12-28T20:51:09 | 2014-12-28T20:51:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,459 | java | import java.util.ArrayList;
import java.util.HashMap;
public class FrontEndServerCache {
/**
* FrontEndServerCache variables: tweetMap, versionMap, lock
*/
private HashMap<String, ArrayList<String>> tweetMap;
private HashMap<String, Integer> versionMap;
private MultiReaderLock lock = new MultiReaderLock();
/**
* Default constructor
*/
public FrontEndServerCache(){
tweetMap = new HashMap<String, ArrayList<String>>();
versionMap = new HashMap<String, Integer>();
}
/**
* Return all tweets with the corresponding hashtag
* @param hashtag
* @return
*/
public ArrayList<String> getTweet(String hashtag){
lock.lockRead();
ArrayList<String> tweets = null;
if (tweetMap.containsKey(hashtag)){
tweets = tweetMap.get(hashtag);
}
lock.unlockRead();
return tweets;
}
/**
* Return current version of tweets for corresponding hashtag
* @param hashtag
* @return
*/
public Integer getVersion(String hashtag){
lock.lockRead();
Integer version = 0;
if (versionMap.containsKey(hashtag)){
version = versionMap.get(hashtag);
}
lock.unlockRead();
return version;
}
/**
* Update tweets and version for the corresponding hashtag
* @param newVersion
* @param query
* @param tweets
*/
public void updateQuery(Integer newVersion, String query, ArrayList<String> tweets){
lock.lockWrite();
versionMap.put(query, newVersion);
tweetMap.put(query, tweets);
lock.unlockWrite();
}
}
| [
"[email protected]"
] | |
be9a167286d5ca77147dad4dc671453e7afe7a2b | 04693f5b6ebf2bb50cdec640beed04673f4742be | /src/test/java/com/javarzn/calc/CalculatorTest.java | add70cc37d79c16a45f2b0805daef3a68b2de18f | [] | no_license | dimamonb/calc-test | 8e6f4086a79d1fa456b99eda11509b7a759144b2 | 8ef8bb6258429e814ed22bb9d0a954298e8512f9 | refs/heads/master | 2020-04-29T07:28:31.884633 | 2019-03-16T09:46:47 | 2019-03-16T09:46:47 | 175,954,014 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,098 | java | package com.javarzn.calc;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
public class CalculatorTest {
private Calculator calc;
private long a = 2;
private long b = 8;
@Before
public void setUp(){
this.calc = new Calculator();
}
@Test
public void testSummarize() {
assertEquals("Summarize invalid",10, calc.summarize(a,b));
}
@Test
public void testSubtract() {
assertThat(calc.subtract(a, b), is(-6L));
}
@Test
public void testMultiply() {
assertThat(calc.multiply(a, b), is(16L));
}
@Test
public void testDivide() {
assertThat(calc.divide(b, a), is(4L));
}
@Test
public void testSqrt() {
assertThat(calc.sqrt(81), is(9.0));
}
@Test
public void testPow() {
assertThat(calc.pow(a, b), is(256L));
}
@Test
public void testSin() {
}
@Test
public void testCos() {
}
@Test
public void testTan() {
}
} | [
"[email protected]"
] | |
ff88935ecb6fe6af22105ce87c09ca8ea9666626 | a0b4b7952d0d0a745909fe4d44baeb7a2d38a298 | /demo/src/main/java/com/fh/service/impl/CategoryServiceImpl.java | 498ac81c2308c2a4f92042967dd46d4280f0d980 | [] | no_license | iteinstein/repo1 | fd77d77d0f490eae88c1081835e0ae5b6c3ace55 | 96bcd4827df5f1538db5ee2134f3c7ad53167e4d | refs/heads/master | 2022-12-24T04:29:28.104943 | 2020-01-12T03:43:48 | 2020-01-12T03:43:48 | 233,203,073 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,678 | java | package com.fh.service.impl;
import com.fh.mapper.CategoryMapper;
import com.fh.model.Category;
import com.fh.service.CategoryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service("categoryService")
public class CategoryServiceImpl implements CategoryService {
@Autowired
private CategoryMapper categoryMapper;
@Override
public List<Category> queryCategoryList() {
List<Category> allCategoryList = categoryMapper.queryCategoryList();
List<Category> categoryList = getChildren(allCategoryList,null);
return categoryList;
}
@Override
public Integer addCategory(Category category) {
categoryMapper.addCategory(category);
return category.getId();
}
@Override
public Category getCategoryById(Integer id) {
return categoryMapper.getCategoryById(id);
}
@Override
public void deleteCategory(Integer[] ids) {
categoryMapper.deleteCategory(ids);
}
@Override
public void updateCategory(Category category) {
categoryMapper.updateCategory(category);
}
public List<Category> getChildren(List<Category> allCategoryList,Integer pid){
List<Category> categoryList = new ArrayList<>();
for(Category category : allCategoryList){
if(category.getPid() == pid){
List<Category> children = getChildren(allCategoryList,category.getId());
category.setChildren(children);
categoryList.add(category);
}
}
return categoryList;
}
}
| [
"[email protected]"
] | |
4bb8d26d278d1fdb14ee3bd45f6accb530209ae5 | 697306f68893d4f2d041a2351e61b5ecd9ad7a45 | /src/sample/Model/StudentDb.java | acd90b84bd47902b392ecde077484b2b82ded31d | [] | no_license | dimayasyuk/Student | 200ac68516dd34ea7dd4f88faa5d9357d9c5ab78 | 89886c4dd7087cab56f4c6b74a1dae000e75b137 | refs/heads/master | 2020-03-21T20:06:58.258858 | 2018-06-28T08:14:57 | 2018-06-28T08:14:57 | 132,333,082 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 815 | java | package sample.Model;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* Created by dmitriy on 4.6.18.
*/
public class StudentDb {
private File file;
private List<Student> students = new ArrayList<>();
public List<Student> getStudents() {
return new ArrayList<>(students);
}
public void setStudents(List<Student> students) {
this.students = new ArrayList<>(students);
}
public void addStudent(Student student){
students.add(student);
}
public File getFile() {
return file;
}
public void setFile(File file) {
this.file = file;
}
public int getStudentsSize(){
return students.size();
}
public void removeStudent(Student student){
students.remove(student);
}
}
| [
"yasyukevich99bk.ru"
] | yasyukevich99bk.ru |
593b559748b20a004cb8d7020b080c5413c1655d | fa49175ab2aaf2dac2a078cd9c392da79cf1088d | /common/darkknight/jewelrycraft/block/BlockShadow.java | 1e58d549e93fe4f95521074daf7872e0ebb3dd83 | [] | no_license | Tosotada/Jewelrycraft | 12d00b9247228b151cd64e3226494db4f32ce06c | 992a30c03cb9493312112aa81f15cfbabb94723a | refs/heads/master | 2020-03-24T12:36:20.265221 | 2014-07-16T10:12:10 | 2014-07-16T10:12:10 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,818 | java | package darkknight.jewelrycraft.block;
import darkknight.jewelrycraft.tileentity.TileEntityBlockShadow;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.Icon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
public class BlockShadow extends BlockContainer
{
private Icon[] iconArray;
public BlockShadow(int par1)
{
super(par1, Material.iron);
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
public int getRenderBlockPass()
{
return 1;
}
public boolean isBeaconBase(World worldObj, int x, int y, int z, int beaconX, int beaconY, int beaconZ)
{
return true;
}
public boolean isOpaqueCube()
{
return false;
}
public boolean renderAsNormalBlock()
{
return false;
}
public boolean isBlockSolidOnSide(World world, int x, int y, int z, ForgeDirection side)
{
return false;
}
public static boolean isNormalCube(int par0)
{
return true;
}
@Override
public TileEntity createNewTileEntity(World world)
{
return new TileEntityBlockShadow();
}
public void registerIcons(IconRegister par1IconRegister)
{
this.iconArray = new Icon[16];
for (int i = 0; i < this.iconArray.length; ++i)
{
this.iconArray[i] = par1IconRegister.registerIcon(this.getTextureName() + (15 - i));
}
}
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
{
if(world.getBlockMetadata(x, y, z) == 15) return null;
return super.getCollisionBoundingBoxFromPool(world, x, y, z);
}
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
public boolean shouldSideBeRendered(IBlockAccess iBlockAccess, int par2, int par3, int par4, int par5)
{
return iBlockAccess.isAirBlock(par2, par3, par4)?true:iBlockAccess.isBlockNormalCube(par2, par3, par4)?false:(iBlockAccess.getBlockId(par2, par3, par4) == BlockList.shadowBlock.blockID)?false:true;
}
public boolean hasComparatorInputOverride()
{
return true;
}
public int getComparatorInputOverride(World world, int x, int y, int z, int meta)
{
return world.getBlockMetadata(x, y, z);
}
public Icon getIcon(int par1, int par2)
{
return this.iconArray[par2];
}
}
| [
"[email protected]"
] | |
15a13a0a32b9285399ca5b20079aa78033cad7af | 1ba8d1a6fe8c0ffb463b2486e9311f46b2ccd956 | /src/com/training/sorting/QuickSort.java | 5847cd13d1be85820873880152c6253897d888b1 | [] | no_license | Lokicoule/dataStructure | 5fd4b27d7d183295bfbe36787211dd09303e8309 | 077ac410c7491194f90f214978a871b8495afbad | refs/heads/master | 2023-02-27T18:03:53.638290 | 2021-02-08T17:40:04 | 2021-02-08T17:40:04 | 329,975,740 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 880 | java | package com.training.sorting;
import java.util.Arrays;
public class QuickSort {
public static void sort(int[] arr) {
quickSort(arr, 0, arr.length - 1);
}
private static void quickSort(int[] arr, int start, int end) {
if (start >= end)
return;
var boundary = partition(arr, start, end);
quickSort(arr, start, boundary - 1);
quickSort(arr, boundary + 1, end);
}
private static int partition(int[] arr, int start, int end) {
var pivot = arr[end];
var boundary = start - 1;
for (var i = start; i <= end; i++) {
if (arr[i] <= pivot)
swap(arr, i, ++boundary);
}
return boundary;
}
private static void swap(int[] arr, int one, int two) {
var temp = arr[one];
arr[one] = arr[two];
arr[two] = temp;
}
}
| [
"[email protected]"
] | |
5ebc1a0d69f2300fcfc3fc720fa5ccf28d4d862c | 361639e6ca0053604deea5dd448dea0a6c29d57d | /simba-core/src/main/java/org/simbasecurity/core/service/AuthorizationRequestContext.java | 67a74eafce26a6efc003560312ca939db09c301b | [] | no_license | cycled/simba-os | ac17a645ae667c1aef8f49711eaf6efbd383ed02 | a5959d98dc7b4cc2641d9a807d829d8a4fa5b1ef | refs/heads/master | 2021-01-22T19:59:29.851097 | 2017-03-15T15:22:40 | 2017-03-15T15:22:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,295 | java | /*
* Copyright 2011 Simba Open Source
*
* 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.simbasecurity.core.service;
/**
* Contains data related to this authorization request, such as username. Used
* by conditions to check if they apply.
*
* @see org.simbasecurity.core.domain.Condition
*/
public class AuthorizationRequestContext {
private final String username;
private final long time;
/**
* Initialize fields username and time. Time is set to current system time.
*/
public AuthorizationRequestContext(String username) {
this.username = username;
this.time = System.currentTimeMillis();
}
public String getUsername() {
return username;
}
public long getTime() {
return time;
}
}
| [
"[email protected]"
] | |
c5463e4a9c4c16a81fa8b5f1926a6f882719555a | 03bf0fe651a672472e0d39ea7692fa99853e6b04 | /src/test/java/com/fu/blogsystemmaven/service/UserServiceTest.java | 9f4eacf141fc8fe6e82c4177f62e714b33a46e1c | [] | no_license | wunaifu/BlogSystemMaven | e65da7367557dfa6c1aa31e473ad6505f3914f24 | 497a80086e66821342fd4f10bac142c53c8139ba | refs/heads/master | 2021-01-15T12:37:41.169715 | 2017-08-08T05:35:34 | 2017-08-08T05:35:34 | 99,653,807 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,847 | java | package com.fu.blogsystemmaven.service;
import com.fu.blogsystemmaven.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
import static org.junit.Assert.*;
/**
* Created by wunaifu on 2017/8/6.
*/
@RunWith(SpringJUnit4ClassRunner.class)
//告诉junit spring的配置文件
@ContextConfiguration({"classpath:spring/spring-dao.xml",
"classpath:spring/spring-service.xml"})
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
public void addUserByPam() throws Exception {
int flag = userService.addUserByPam("18219111604", "123456");
System.out.println("添加返回=="+flag);
}
@Test
public void deleteUserByPhone() throws Exception {
int flag = userService.deleteUserByPhone("18219111604");
System.out.println("删除返回==" + flag);
}
@Test
public void updateAndAddUser() throws Exception {
int flag=0;
try {
flag = userService.updateAndAddUser(
"18219111605", "update1234", "18219111606", "123456add");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("更新返回==" + flag);
}
@Test
public void findUserByPhone() throws Exception {
User user = userService.findUserByPhone("18219111624");
System.out.println("查找User==="+user);
}
@Test
public void findAllUser() throws Exception {
List<User> userList=userService.findAllUser();
for (User user : userList) {
System.out.println("User===="+user);
}
}
} | [
"[email protected]"
] | |
18c175a725ee7fff76b6386afcee3791a713282e | 3946016d4f133f44532856e6f9b95bee4b238a8f | /movie-catalog-service/src/main/java/com/example/moviecatalogservice/model/external/Rating.java | 0e28ecd1ee4a9a178f0eb20fd000b3beb817ee51 | [] | no_license | msmandy94/microservices-javaBrains | 6a1ff24b445966ad475a5372b785597093137c3d | 945dc111e018fdd5a21c655555f93b8a0cd854af | refs/heads/master | 2020-09-21T12:24:46.912936 | 2019-12-12T10:44:53 | 2019-12-12T10:44:53 | 224,788,254 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 559 | java | package com.example.moviecatalogservice.model.external;
public class Rating {
private String movieId;
private int rating;
public Rating(){}
public Rating(String movieId, int rating) {
this.movieId = movieId;
this.rating = rating;
}
public String getMovieId() {
return movieId;
}
public void setMovieId(String movieId) {
this.movieId = movieId;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
}
| [
"[email protected]"
] | |
ca1e5d20da208c3f28e566885bfff426221a38b9 | ad3aaff76ac97405c04a79ac916d50a3935bbf6e | /src/main/java/ru/kappers/model/utilmodel/Outcomes.java | 9d1c248282f05d6c0a6a11ebf9d246e2f93ef06a | [] | no_license | soufee/kappers | 40f1607483256c9fc66f3be27b610c38f1b976a6 | 3c89136795ed2db960f8c0200f04c99f77b8ba78 | refs/heads/master | 2021-06-12T07:42:06.939934 | 2019-10-30T21:29:19 | 2019-10-30T21:29:19 | 153,514,565 | 0 | 4 | null | 2019-10-30T21:29:20 | 2018-10-17T19:47:27 | Java | UTF-8 | Java | false | false | 317 | java | package ru.kappers.model.utilmodel;
/**
* Список возможных исходов.
* В перспективе надо расширить до тоталов, двойных исходов, форы и т.д.
* */
public enum Outcomes {
HOMETEAMWIN, //П1
DRAW, //Х
GUESTTEAMWIN //П2
}
| [
"[email protected]"
] | |
0c8c9c0906dd9b9602c767dabfd58777c81e5b4a | 2da705ba188bb9e4a0888826818f1b25d04e90c8 | /support/cas-server-support-pm/src/test/java/org/apereo/cas/pm/impl/GroovyResourcePasswordManagementServiceTests.java | 7411a06af666493e9fef2ae99cebec1ebec9b5cd | [
"LicenseRef-scancode-free-unknown",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | williamadmin/cas | 9441fd730de81a5abaf173e2e831a19c9e417579 | a4c49ab5137745146afa0f6d41791c2881a344a6 | refs/heads/master | 2021-05-25T19:05:01.862668 | 2020-04-07T05:15:53 | 2020-04-07T05:15:53 | 253,788,442 | 1 | 0 | Apache-2.0 | 2020-04-07T12:37:38 | 2020-04-07T12:37:37 | null | UTF-8 | Java | false | false | 1,829 | java | package org.apereo.cas.pm.impl;
import org.apereo.cas.authentication.CoreAuthenticationTestUtils;
import org.apereo.cas.config.CasCoreUtilConfiguration;
import org.apereo.cas.pm.PasswordChangeRequest;
import org.apereo.cas.pm.PasswordManagementService;
import org.apereo.cas.pm.config.PasswordManagementConfiguration;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration;
import static org.junit.jupiter.api.Assertions.*;
/**
* This is {@link GroovyResourcePasswordManagementServiceTests}.
*
* @author Misagh Moayyed
* @since 6.1.0
*/
@SpringBootTest(classes = {
RefreshAutoConfiguration.class,
PasswordManagementConfiguration.class,
CasCoreUtilConfiguration.class
}, properties = {
"cas.authn.pm.enabled=true",
"cas.authn.pm.groovy.location=classpath:/GroovyPasswordMgmt.groovy"
})
@Tag("Groovy")
public class GroovyResourcePasswordManagementServiceTests {
@Autowired
@Qualifier("passwordChangeService")
private PasswordManagementService passwordChangeService;
@Test
public void verifyFindEmail() {
assertNotNull(passwordChangeService.findEmail("casuser"));
}
@Test
public void verifyFindUser() {
assertNotNull(passwordChangeService.findUsername("[email protected]"));
}
@Test
public void verifyChangePassword() {
assertTrue(passwordChangeService.change(
CoreAuthenticationTestUtils.getCredentialsWithDifferentUsernameAndPassword("casuser", "password"),
new PasswordChangeRequest("casuser", "password", "password")));
}
}
| [
"[email protected]"
] | |
e3f1b22b2baebebb59fd3c34499004f58dd83e20 | 1403491f673d8133d3da66f36708fcd0185e641a | /common/src/main/java/com/leaf/jobs/utils/StackTraceUtil.java | 930cd4e9ae62992e206e818be097bf50738cb6a5 | [] | no_license | tiny-x/leaf-jobs | e0999e31540a64675e8b8890d66c6cbc54df3e30 | 438d5d7af19877d5bb6f6e94c24eab8a0ea32cbb | refs/heads/master | 2022-08-22T01:58:03.444448 | 2020-05-25T10:54:35 | 2020-05-25T10:54:35 | 248,924,700 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 665 | java | package com.leaf.jobs.utils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
public final class StackTraceUtil {
public static String stackTrace(Throwable t) {
if (t == null) {
return "null";
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(out);
t.printStackTrace(ps);
ps.flush();
try {
return new String(out.toByteArray());
} finally {
try {
out.close();
} catch (IOException ignored) {}
}
}
private StackTraceUtil() {}
} | [
"[email protected]"
] | |
6048f46b50f007637a99a5eb01c18bc52112c354 | e26b552cbdae26e099f9f011eb8ed08cfba41315 | /bootstrapProject/saludcoop/commons/src/main/java/com/conexia/saludcoop/common/entity/maestro/EstadoVisible.java | da6857138164114e526ac12d8341b9238f799174 | [] | no_license | maes0186/ABBAPrototipo1 | 3c9575b66360b1960eec0b63e8c549dbbf6c14a5 | 2d0de9a18b54ee8a17a2ba10a25a4357a6708cd5 | refs/heads/master | 2021-01-10T07:44:58.067830 | 2015-11-08T00:38:39 | 2015-11-08T00:38:39 | 45,358,707 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 238 | java | package com.conexia.saludcoop.common.entity.maestro;
import javax.persistence.Entity;
import javax.persistence.Table;
@Entity
@Table(name="estado_visible", schema="maestros")
public class EstadoVisible extends Descriptivo{
}
| [
"maes0186@aa3da725-fa38-4a37-849c-0e1cb1b97359"
] | maes0186@aa3da725-fa38-4a37-849c-0e1cb1b97359 |
a8a1eb9a9fc7274710aee7eaac007486df9224f5 | 0311f60e905d6d0665814c6b75567e47921ea985 | /x5web/src/main/java/com/sample/x5web/activity/BrowserActivity.java | 31c53a026b8d51013b171e287cecf52a95b56943 | [] | no_license | GodferyChen/StuffApp | f48d76f96ed773ecb264818d958811041a75d6d6 | 91cddd22fbf4210311fc6af4532fd494b59792c2 | refs/heads/master | 2020-03-25T09:20:37.473080 | 2018-10-06T12:22:33 | 2018-10-06T12:22:33 | 143,660,950 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 16,156 | java | package com.sample.x5web.activity;
import android.annotation.SuppressLint;
import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Process;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.FrameLayout;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.Toast;
import com.sample.base.BaseActivity;
import com.sample.x5web.R;
import com.sample.x5web.helper.X5WebView;
import com.tencent.smtt.export.external.interfaces.IX5WebChromeClient;
import com.tencent.smtt.export.external.interfaces.JsResult;
import com.tencent.smtt.sdk.CookieSyncManager;
import com.tencent.smtt.sdk.ValueCallback;
import com.tencent.smtt.sdk.WebChromeClient;
import com.tencent.smtt.sdk.WebSettings;
import com.tencent.smtt.sdk.WebView;
import com.tencent.smtt.sdk.WebViewClient;
import com.tencent.smtt.utils.TbsLog;
import java.net.URL;
import java.util.Objects;
import butterknife.BindView;
/**
* @author chen
* @version 1.0.0
* @date 2018/8/20
* @Description 作为一个浏览器的示例展示出来，采用android+web的模式
*/
public class BrowserActivity extends BaseActivity {
private X5WebView mWebView;
@BindView(R.id.webView1)
ViewGroup mViewParent;
@BindView(R.id.btnBack1)
ImageButton mBack;
@BindView(R.id.btnForward1)
ImageButton mForward;
@BindView(R.id.btnExit1)
ImageButton mExit;
@BindView(R.id.btnHome1)
ImageButton mHome;
@BindView(R.id.btnMore)
ImageButton mMore;
@BindView(R.id.btnGo1)
Button mGo;
@BindView(R.id.editUrl1)
EditText mUrl;
private static final String mHomeUrl = "http://app.html5.qq.com/navi/index";
private static final String TAG = "SdkDemo";
private static final int MAX_LENGTH = 14;
private boolean mNeedTestPage = false;
private final int disable = 120;
private final int enable = 255;
@BindView(R.id.progressBar1)
ProgressBar mPageLoadingProgressBar = null;
private ValueCallback<Uri> uploadFile;
private URL mIntentUrl;
public static final int MSG_OPEN_TEST_URL = 0;
public static final int MSG_INIT_UI = 1;
private final int mUrlStartNum = 0;
private int mCurrentUrl = mUrlStartNum;
@SuppressLint("HandlerLeak")
private Handler mTestHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_OPEN_TEST_URL:
if (!mNeedTestPage) {
return;
}
String testUrl = "file:///sdcard/outputHtml/html/"
+ Integer.toString(mCurrentUrl) + ".html";
if (mWebView != null) {
mWebView.loadUrl(testUrl);
}
mCurrentUrl++;
break;
case MSG_INIT_UI:
initWebViewSetting();
break;
default:
break;
}
super.handleMessage(msg);
}
};
@Override
protected int getLayoutId() {
return R.layout.activity_browser;
}
@Override
protected void init(Bundle savedInstanceState) {
getWindow().setFormat(PixelFormat.TRANSLUCENT);
mContext = this;
Intent intent = getIntent();
if (intent != null) {
try {
mIntentUrl = new URL(Objects.requireNonNull(intent.getData()).toString());
if (Integer.parseInt(android.os.Build.VERSION.SDK) >= android.os.Build.VERSION_CODES.HONEYCOMB) {
getWindow().setFlags(
android.view.WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
android.view.WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);
/*
* getWindow().addFlags(
* android.view.WindowManager.LayoutParams.FLAG_FULLSCREEN);
*/
}
} catch (Exception e) {
e.printStackTrace();
}
}
initBtnListener();
mTestHandler.sendEmptyMessageDelayed(MSG_INIT_UI, 10);
}
private void initWebViewSetting() {
mWebView = new X5WebView(this, null);
mViewParent.addView(mWebView, new FrameLayout.LayoutParams(
FrameLayout.LayoutParams.MATCH_PARENT,
FrameLayout.LayoutParams.MATCH_PARENT));
initProgressBar();
mWebView.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
return false;
}
@Override
public void onPageFinished(WebView view, String url) {
super.onPageFinished(view, url);
// mTestHandler.sendEmptyMessage(MSG_OPEN_TEST_URL);
mTestHandler.sendEmptyMessageDelayed(MSG_OPEN_TEST_URL, 5000);
if (Integer.parseInt(android.os.Build.VERSION.SDK) >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
changGoForwardButton(view);
}
/* mWebView.showLog("test Log"); */
}
});
mWebView.setWebChromeClient(new WebChromeClient() {
@Override
public boolean onJsConfirm(WebView arg0, String arg1, String arg2,
JsResult arg3) {
return super.onJsConfirm(arg0, arg1, arg2, arg3);
}
View myVideoView;
View myNormalView;
IX5WebChromeClient.CustomViewCallback callback;
/**
* 全屏播放配置
*/
@Override
public void onShowCustomView(View view,
IX5WebChromeClient.CustomViewCallback customViewCallback) {
FrameLayout normalView = findViewById(R.id.web_filechooser);
ViewGroup viewGroup = (ViewGroup) normalView.getParent();
viewGroup.removeView(normalView);
viewGroup.addView(view);
myVideoView = view;
myNormalView = normalView;
callback = customViewCallback;
}
@Override
public void onHideCustomView() {
if (callback != null) {
callback.onCustomViewHidden();
callback = null;
}
if (myVideoView != null) {
ViewGroup viewGroup = (ViewGroup) myVideoView.getParent();
viewGroup.removeView(myVideoView);
viewGroup.addView(myNormalView);
}
}
@Override
public boolean onJsAlert(WebView arg0, String arg1, String arg2,
JsResult arg3) {
/**
* 这里写入你自定义的window alert
*/
return super.onJsAlert(null, arg1, arg2, arg3);
}
});
mWebView.setDownloadListener((arg0, arg1, arg2, arg3, arg4) -> {
TbsLog.d(TAG, "url: " + arg0);
new AlertDialog.Builder(BrowserActivity.this)
.setTitle("allow to download？")
.setPositiveButton("yes",
(dialog, which) -> showToast("fake message: i'll download..."))
.setNegativeButton("no",
(dialog, which) -> {
showToast("fake message: refuse download...");
})
.setOnCancelListener(
dialog -> {
showToast("fake message: refuse download...");
}).show();
});
WebSettings webSetting = mWebView.getSettings();
webSetting.setAllowFileAccess(true);
webSetting.setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NARROW_COLUMNS);
webSetting.setSupportZoom(true);
webSetting.setBuiltInZoomControls(true);
webSetting.setUseWideViewPort(true);
webSetting.setSupportMultipleWindows(false);
// webSetting.setLoadWithOverviewMode(true);
webSetting.setAppCacheEnabled(true);
// webSetting.setDatabaseEnabled(true);
webSetting.setDomStorageEnabled(true);
webSetting.setJavaScriptEnabled(true);
webSetting.setGeolocationEnabled(true);
webSetting.setAppCacheMaxSize(Long.MAX_VALUE);
webSetting.setAppCachePath(this.getDir("appcache", 0).getPath());
webSetting.setDatabasePath(this.getDir("databases", 0).getPath());
webSetting.setGeolocationDatabasePath(this.getDir("geolocation", 0)
.getPath());
// webSetting.setPageCacheCapacity(IX5WebSettings.DEFAULT_CACHE_CAPACITY);
webSetting.setPluginState(WebSettings.PluginState.ON_DEMAND);
// webSetting.setRenderPriority(WebSettings.RenderPriority.HIGH);
// webSetting.setPreFectch(true);
long time = System.currentTimeMillis();
if (mIntentUrl == null) {
mWebView.loadUrl(mHomeUrl);
} else {
mWebView.loadUrl(mIntentUrl.toString());
}
TbsLog.d("time-cost", "cost time: "
+ (System.currentTimeMillis() - time));
CookieSyncManager.createInstance(this);
CookieSyncManager.getInstance().sync();
}
private void initBtnListener() {
if (Integer.parseInt(android.os.Build.VERSION.SDK) >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
mBack.setAlpha(disable);
mForward.setAlpha(disable);
mHome.setAlpha(disable);
}
mHome.setEnabled(false);
mBack.setOnClickListener(v -> {
if (mWebView != null && mWebView.canGoBack()) {
mWebView.goBack();
}
});
mForward.setOnClickListener(v -> {
if (mWebView != null && mWebView.canGoForward()) {
mWebView.goForward();
}
});
mGo.setOnClickListener(v -> {
String url = mUrl.getText().toString();
mWebView.loadUrl(url);
mWebView.requestFocus();
});
mMore.setOnClickListener(v -> showToast("not completed"));
mUrl.setOnFocusChangeListener((v, hasFocus) -> {
if (hasFocus) {
mGo.setVisibility(View.VISIBLE);
if (null == mWebView.getUrl()) {
return;
}
if (mWebView.getUrl().equalsIgnoreCase(mHomeUrl)) {
mUrl.setText("");
mGo.setText("首页");
mGo.setTextColor(0X6F0F0F0F);
} else {
mUrl.setText(mWebView.getUrl());
mGo.setText("进入");
mGo.setTextColor(0X6F0000CD);
}
} else {
mGo.setVisibility(View.GONE);
String title = mWebView.getTitle();
if (title != null && title.length() > MAX_LENGTH) {
mUrl.setText(title.subSequence(0, MAX_LENGTH) + "...");
} else {
mUrl.setText(title);
}
InputMethodManager imm = (InputMethodManager) getSystemService(Context
.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}
});
mUrl.addTextChangedListener(new TextWatcher() {
@Override
public void afterTextChanged(Editable s) {
String url = null;
if (mUrl.getText() != null) {
url = mUrl.getText().toString();
}
if (url == null
|| mUrl.getText().toString().equalsIgnoreCase("")) {
mGo.setText("请输入网址");
mGo.setTextColor(0X6F0F0F0F);
} else {
mGo.setText("进入");
mGo.setTextColor(0X6F0000CD);
}
}
@Override
public void beforeTextChanged(CharSequence arg0, int arg1,
int arg2, int arg3) {
}
@Override
public void onTextChanged(CharSequence arg0, int arg1, int arg2,
int arg3) {
}
});
mHome.setOnClickListener(v -> {
if (mWebView != null) {
mWebView.loadUrl(mHomeUrl);
}
});
mExit.setOnClickListener(v -> Process.killProcess(Process.myPid()));
}
private void initProgressBar() {
mPageLoadingProgressBar.setMax(100);
mPageLoadingProgressBar.setProgressDrawable(this.getResources()
.getDrawable(R.drawable.color_progressbar));
}
private void changGoForwardButton(WebView view) {
if (view.canGoBack()) {
mBack.setAlpha(enable);
} else {
mBack.setAlpha(disable);
}
if (view.canGoForward()) {
mForward.setAlpha(enable);
} else {
mForward.setAlpha(disable);
}
if (view.getUrl() != null && view.getUrl().equalsIgnoreCase(mHomeUrl)) {
mHome.setAlpha(disable);
mHome.setEnabled(false);
} else {
mHome.setAlpha(enable);
mHome.setEnabled(true);
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
if (mWebView != null && mWebView.canGoBack()) {
mWebView.goBack();
if (Integer.parseInt(android.os.Build.VERSION.SDK) >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
changGoForwardButton(mWebView);
}
return true;
} else {
return super.onKeyDown(keyCode, event);
}
}
return super.onKeyDown(keyCode, event);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
TbsLog.d(TAG, "onActivityResult, requestCode:" + requestCode
+ ",resultCode:" + resultCode);
if (resultCode == RESULT_OK) {
switch (requestCode) {
case 0:
if (null != uploadFile) {
Uri result = data == null ? null : data.getData();
uploadFile.onReceiveValue(result);
uploadFile = null;
}
break;
default:
break;
}
} else if (resultCode == RESULT_CANCELED) {
if (null != uploadFile) {
uploadFile.onReceiveValue(null);
uploadFile = null;
}
}
}
@Override
protected void onNewIntent(Intent intent) {
if (intent == null || mWebView == null || intent.getData() == null) {
return;
}
mWebView.loadUrl(intent.getData().toString());
}
@Override
protected void onDestroy() {
if (mTestHandler != null) {
mTestHandler.removeCallbacksAndMessages(null);
}
if (mWebView != null) {
mWebView.destroy();
}
super.onDestroy();
}
private void showToast(String text) {
Toast.makeText(mContext, text, Toast.LENGTH_SHORT).show();
}
}
| [
"[email protected]"
] | |
c51eb5b58cd240abba1fd90a06d2ca54eb2e29cd | fcff572da1d3563f174319fb6d363f793d1fffff | /utils/Color.java | 74142e1023e45348af6a3876472de3e18edd0236 | [] | no_license | niteshpatel/hdfw | 039cf1d5d7a64506ca3ce90bcc1f79d27714ba69 | 012a0256272522caaefa552fe33b661c8315b15c | refs/heads/master | 2021-01-12T13:51:55.968311 | 2013-06-02T17:54:47 | 2013-06-02T17:54:47 | 69,198,096 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 269 | java | package com.herodevelop.hdfw.utils;
public class Color {
public float red;
public float green;
public float blue;
public Color(float red, float green, float blue) {
this.red = red;
this.green = green;
this.blue = blue;
}
}
| [
"[email protected]"
] | |
9e6690d23cbb417126225d8ae0692cdffeb7cfcc | 3f7681d75e10aaee5bff3d9c74500b7880a50df3 | /src/main/java/kr/or/ddit/elecAuthorization/controller/sangshin/SangshinRetreiveController.java | a935b336d55b93c7404cb6ca1c09500d4f7e9b94 | [] | no_license | lcy7747/eclipseGit | 52186ad24cffaff5e18f8ac56a3ba6329881f369 | 506230a6c4f4067fce968d3eebd3e15328706940 | refs/heads/master | 2022-11-18T19:21:14.272478 | 2019-06-19T11:00:11 | 2019-06-19T11:00:11 | 192,713,238 | 0 | 0 | null | 2022-11-16T11:49:31 | 2019-06-19T10:45:38 | Java | UTF-8 | Java | false | false | 2,488 | java | package kr.or.ddit.elecAuthorization.controller.sangshin;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import kr.or.ddit.elecAuthorization.service.ISangshinService;
import kr.or.ddit.vo.Elec_ApprovalVO;
import kr.or.ddit.vo.EmployeeVO;
import kr.or.ddit.vo.PagingVO;
import kr.or.ddit.vo.SendVO;
@Controller
public class SangshinRetreiveController {
@Inject
ISangshinService sangshinService;
// 동기처리
@RequestMapping("/elecAuthorization/sangshin/sangshinList")
public String getApproList(
@RequestParam(required=false) String searchType
, @RequestParam(required=false) String searchWord
, @RequestParam(name="page", required=false , defaultValue="1") long currentPage
, Model model
, Authentication user
){
PagingVO<Elec_ApprovalVO> pagingVO = new PagingVO<>();
pagingVO.setSearchType(searchType);
pagingVO.setSearchWord(searchWord);
EmployeeVO employee = (EmployeeVO) user.getPrincipal();
String loginUserId = employee.getEmp_id();
pagingVO.setEmp_id(loginUserId);
long totalRecord = sangshinService.retreiveSangShinCount(pagingVO);
pagingVO.setCurrentPage(currentPage);
pagingVO.setTotalRecord(totalRecord);
List<Elec_ApprovalVO> sangshinList = sangshinService.retreiveSangShinList(pagingVO);
pagingVO.setDataList(sangshinList);
model.addAttribute("pagingVO", pagingVO);
return "elec/sangshin/sangshinList";
}
// 상신(기안서) 상세 조회
@RequestMapping("/elecAuthorization/sangshin/sangshinView")
public String getSangshinView(
@RequestParam(name="what") String elec_noStr
, Model model
, Authentication user
){
int elec_no = Integer.parseInt(elec_noStr);
EmployeeVO employee = (EmployeeVO) user.getPrincipal();
String loginUserId = employee.getEmp_id();
Elec_ApprovalVO approval = new Elec_ApprovalVO();
approval.setElec_no(elec_no);
approval.setElec_writer(loginUserId);
Elec_ApprovalVO sangshin = sangshinService.retreiveSangShin(approval);
model.addAttribute("sangshin", sangshin);
return "elec/sangshin/sangshinView";
}
}
| [
"[email protected]"
] | |
6ce021783b85383299aa4d04b41c7d191784dfe1 | dcbf0c97a0526e01dda58f3ea3aa08daf4719342 | /Collection-TreeSet.java | 27f44434be7dab70bc7540398efc715801eae782 | [] | no_license | vasanth-web/Java-Practice | 56909f62f8ab4c607a59dd3d818d6f48e0bd7d4d | d58eb514b3c035bcb3200b1ae1332bd45eca2277 | refs/heads/master | 2023-08-31T22:59:06.062543 | 2021-10-11T16:02:00 | 2021-10-11T16:02:00 | 415,987,122 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,711 | java | package com.company;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<Integer> set = new TreeSet<>();
set.add(0);
set.add(1);
set.add(2);
set.add(3);
set.add(4);
set.add(5);
set.add(6);
// Get a reverse view of the navigable set
NavigableSet<Integer> reverseNs = set.descendingSet();
// Print the normal and reverse views
System.out.println("Normal order: " + set);
System.out.println("Reverse order: " + reverseNs);
NavigableSet<Integer> threeOrMore = set.tailSet(3, true);
System.out.println("3 or more: " + threeOrMore);
System.out.println("lower(3): " + set.lower(3));
System.out.println("higher(3): " + set.higher(3));
System.out.println("floor(3): " + set.floor(3));
System.out.println("ceiling(3): " + set.ceiling(3));
System.out.println("pollFirst(): " + set.pollFirst());
System.out.println("Navigable Set: " + set);
System.out.println("pollLast(): " + set.pollLast());
System.out.println("Navigable Set: " + set);
System.out.println("pollFirst(): " + set.pollFirst());
System.out.println("Navigable Set: " + set);
System.out.println("pollFirst(): " + set.pollFirst());
System.out.println("Navigable Set: " + set);
System.out.println("pollFirst(): " + set.pollFirst());
System.out.println("Navigable Set: " + set);
System.out.println("pollFirst(): " + set.pollFirst());
System.out.println("pollLast(): " + set.pollLast());
}
}
| [
"[email protected]"
] | |
0e1472402ea228e60c6f0eaf9efd7f60da974090 | c14dc284911e121d600d29c6e69921822cc8317f | /app/src/main/java/cn/bmob/im/MyBmobQuery.java | aa159b8f83590abf3b7057f3a1927e63373995c1 | [] | no_license | Zeashon/AMap3.0 | 9eb9dce89c2a93a10bf643d2ffc0303838579cbe | cbf32a50c7f6343eb5c8730098226f11d4823f60 | refs/heads/master | 2020-03-29T11:56:42.732424 | 2015-09-19T15:37:24 | 2015-09-19T15:37:24 | 39,784,930 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,710 | java | package cn.bmob.im;
import android.text.TextUtils;
import android.util.Log;
import com.example.amap.bean.AMapPoint;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import cn.bmob.v3.BmobObject;
import cn.bmob.v3.BmobQuery;
import cn.bmob.v3.BmobUser;
import cn.bmob.v3.datatype.BmobDate;
import cn.bmob.v3.datatype.BmobGeoPoint;
import g.acknowledge;
/**
* Created by Administrator on 2015/8/10.
*/
public class MyBmobQuery<T> extends BmobQuery<T> {
private JSONObject m = new JSONObject();
public BmobQuery<T> addWhereNear(String key, AMapPoint point) {
Log.i("zjx","key:"+key);
this.Code(key, "$nearSphere", point);
return this;
}
public BmobQuery<T> addWhereWithinKilometers(String key, AMapPoint point, double maxDistance) {
this.Code(key, "$maxDistanceInKilometers", point, maxDistance);
return this;
}
private void Code(String var1, String var2, AMapPoint var3, double var4) {
this.Code(var1, "$nearSphere", var3);
this.Code(var1, var2, Double.valueOf(var4));
}
private void Code(String var1, String var2, Object var3) {
try {
BmobUser var4;
JSONObject var5;
BmobObject var8;
if(TextUtils.isEmpty(var2)) {
if(var3 instanceof BmobUser) {
var4 = (BmobUser)var3;
(var5 = new JSONObject()).put("__type", "Pointer");
var5.put("objectId", var4.getObjectId());
var5.put("className", "_User");
this.m.put(var1, var5);
} else if(var3 instanceof BmobObject) {
var8 = (BmobObject)var3;
(var5 = new JSONObject()).put("__type", "Pointer");
var5.put("objectId", var8.getObjectId());
var5.put("className", var8.getClass().getSimpleName());
this.m.put(var1, var5);
} else {
this.m.put(var1, var3);
}
} else {
if(var3 instanceof AMapPoint) {
var3 = new JSONObject(acknowledge.I(var3));
Log.i("zjx","var3 = new JSONObject(acknowledge.I(var3));"+var3);
} else if(var3 instanceof BmobUser) {
var4 = (BmobUser)var3;
(var5 = new JSONObject()).put("__type", "Pointer");
var5.put("objectId", var4.getObjectId());
var5.put("className", "_User");
var3 = var5;
} else if(var3 instanceof BmobObject) {
var8 = (BmobObject)var3;
(var5 = new JSONObject()).put("__type", "Pointer");
var5.put("objectId", var8.getObjectId());
var5.put("className", var8.getClass().getSimpleName());
var3 = var5;
} else if(var3 instanceof BmobDate) {
var3 = new JSONObject(acknowledge.I(var3));
} else if(var3 instanceof ArrayList) {
ArrayList var9 = (ArrayList)var3;
JSONArray var13 = new JSONArray();
JSONObject var10;
(var10 = new JSONObject()).put("__type", "aMapPoint");
var10.put("x", ((AMapPoint) var9.get(0)).getX());
var10.put("y", ((AMapPoint)var9.get(0)).getY());
var10.put("z", ((AMapPoint)var9.get(0)).getZ());
JSONObject var6;
(var6 = new JSONObject()).put("__type", "aMapPoint");
var6.put("x", ((AMapPoint) var9.get(1)).getX());
var6.put("y", ((AMapPoint)var9.get(1)).getY());
var6.put("z", ((AMapPoint)var9.get(1)).getZ());
var13.put(var10);
var13.put(var6);
(var10 = new JSONObject()).put("$box", var13);
var3 = var10;
}
JSONObject var11 = null;
Object var12;
if(this.m.has(var1) && (var12 = this.m.get(var1)) instanceof JSONObject) {
Log.i("zjx",this.m.get(var1).toString());
var11 = (JSONObject)var12;
}
if(var11 == null) {
var11 = new JSONObject();
}
var11.put(var2, var3);
this.m.put(var1, var11);
Log.i("zjx","m:"+m.toString());
}
} catch (JSONException var7) {
var7.printStackTrace();
}
}
}
| [
"[email protected]"
] | |
47a669a2f20a0e7c80a292f18c91a45ab4f3e956 | 663caa044e13033446cc749ee3f59505c867e7cc | /src/main/java/com/example/Cell.java | 4cbba8ad456ce643dc0a0934920a4b083299c146 | [] | no_license | sofsin96/GameOfLife-TDD | 2c6f01e31428c3a245975242d7a1286fc36586a4 | d8a4bf10a227e80eb0859ec02e2646f5a12a8207 | refs/heads/main | 2023-08-27T21:13:51.701175 | 2021-11-07T14:04:52 | 2021-11-07T14:04:52 | 421,356,680 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 667 | java | package com.example;
import static com.example.State.*;
public class Cell {
public static final int MIN_NEIGHBORS_PER_CELL = 2, MAX_NEIGHBORS_PER_CELL = 3, THREE_NEIGHBORS_PER_DEAD_CELL = 3;
private State state;
public Cell(State state) {
this.state = state;
}
public void calculateNextGeneration(int neighbors) {
switch (state) {
case ALIVE -> state = neighbors == MIN_NEIGHBORS_PER_CELL || neighbors == MAX_NEIGHBORS_PER_CELL ? ALIVE : DEAD;
case DEAD -> state = neighbors == THREE_NEIGHBORS_PER_DEAD_CELL ? ALIVE : DEAD;
}
}
public State getState() {
return state;
}
}
| [
"[email protected]"
] | |
b0c4e9e8194b68c76b39e69e8c32a5464f234035 | 9e7f0377209c913f5496cb308a83931ce7a34b73 | /src/main/java/com/incowiz/sample/demo/aspect/LoggingAspect.java | abea0003de830ec629878a5ae54d8b13d6b7ffaa | [
"MIT"
] | permissive | brianjang/springDemo | 1b3b3f53111aee368319a6f26e4b47215be831b9 | b1ddfd14cddbf9f5a0ce372208fbbbabefd40211 | refs/heads/master | 2020-05-25T01:19:45.368577 | 2020-03-06T00:39:25 | 2020-03-06T00:39:25 | 187,553,021 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,436 | java | package com.incowiz.sample.demo.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
@Aspect
@Component
public class LoggingAspect {
@Autowired(required = false)
private HttpServletRequest request;
private Logger log = LoggerFactory.getLogger(this.getClass());
@Before("execution(* com.incowiz.sample.demo.web.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
log.info("[Aspect Before] URL: " + request.getRequestURL() + "URI: " + request.getRequestURI());
log.info("[Aspect Before] Join point kind : {}", joinPoint.getKind());
log.info("[Aspect Before] Signature declaring type : {}", joinPoint.getSignature().getDeclaringTypeName());
log.info("[Aspect Before] Signature name : {}", joinPoint.getSignature().getName());
log.info("[Aspect Before] Arguments : {}", Arrays.toString(joinPoint.getArgs()));
log.info("[Aspect Before] Target class : {}", joinPoint.getTarget().getClass().getName());
log.info("[Aspect Before] This class : {}", joinPoint.getThis().getClass().getName());
}
@After("execution(* com.incowiz.sample.demo.web.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
log.info("[Aspect After] The method {}() begins with {}", joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
log.info("[Aspect After] URL: " + request.getRequestURL() + "URI: " + request.getRequestURI());
}
@AfterReturning(
pointcut = "execution(* com.incowiz.sample.demo.web.*.*(..))",
returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
log.info("[Aspect AfterReturning]The method {}() ends with {}",
joinPoint.getSignature().getName(),
result);
}
@AfterThrowing(
pointcut = "execution(* com.incowiz.sample.demo.web.*.*(..))",
throwing = "e")
public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
log.error("[Aspect AfterThrowing] An exception {} has been throw in {}()",
e,
joinPoint.getSignature().getName());
}
}
| [
"[email protected]"
] | |
bed26358036ebce47c728a65637034c1497b7372 | f4303dd14312f88334ea261843f37c3f833beb9c | /component/common_mvp/src/main/java/com/xiaochen/common/mvp/BaseMvpActivity.java | 7e1fbb28d5ca3c49b5d00ea6e3321371d5679c53 | [] | no_license | zlc921022/easy_component | 1e5112c5df88a7be83da8b0c029dc6464bd76c46 | e0531c63b79dc63c2546466c5e0b867b64973ba4 | refs/heads/master | 2022-09-24T00:36:42.112420 | 2020-06-03T15:33:15 | 2020-06-03T15:33:15 | 258,473,111 | 11 | 2 | null | null | null | null | UTF-8 | Java | false | false | 1,721 | java | package com.xiaochen.common.mvp;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.jaeger.library.StatusBarUtil;
/**
* 所有使用mvp模式的activity的父类
*
* @param <T>
* @author admin
*/
public abstract class BaseMvpActivity<T extends AbsBasePresenter> extends AppCompatActivity {
protected T mPresenter;
protected final String TAG = this.getClass().getSimpleName();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getLayoutResId() == 0) {
return;
}
setContentView(getLayoutResId());
setStatusBar();
initView();
initData();
initListener();
}
/**
* 设置沉浸式 状态栏
*/
protected void setStatusBar() {
StatusBarUtil.setLightMode(this);
StatusBarUtil.setTranslucent(this);
}
/**
* 控件初始化
*/
protected void initView() {
}
/**
* 数据处理
*/
protected void initData() {
mPresenter = getPresenter();
getLifecycle().addObserver(mPresenter);
}
/**
* 事件监听
*/
protected void initListener() {
}
/**
* 获取布局id
*
* @return id
*/
protected int getLayoutResId() {
return 0;
}
/**
* 获取Presenter对象
*
* @return presenter
*/
@NonNull
protected abstract T getPresenter();
@Override
protected void onDestroy() {
getLifecycle().removeObserver(mPresenter);
super.onDestroy();
}
}
| [
"[email protected]"
] | |
ae5bec3efde4d97f0de33add1b45145954ec605f | ac09a467d9981f67d346d1a9035d98f234ce38d5 | /leetcode/src/main/java/org/leetcode/problems/_000684_RedundantConnection.java | df8c3dfc1dd5b40fdcf9e9e1b6fd8604657b746f | [] | no_license | AlexKokoz/leetcode | 03c9749c97c846c4018295008095ac86ae4951ee | 9449593df72d86dadc4c470f1f9698e066632859 | refs/heads/master | 2023-02-23T13:56:38.978851 | 2023-02-12T21:21:54 | 2023-02-12T21:21:54 | 232,152,255 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 540 | java | package org.leetcode.problems;
/**
*
* EASY
*
* @author akokozidis
*
*/
public class _000684_RedundantConnection {
public int[] findRedundantConnection(int[][] edges) {
int[] id = new int[edges.length + 1];
for (int i = 1; i < id.length; i++)
id[i] = i;
for (int[] edge : edges) {
int v = edge[0];
int w = edge[1];
int p = find(v, id);
int q = find(w, id);
if (p == q) return edge;
id[p] = q;
}
return new int[2];
}
int find(int v, int[] id) {
while (id[v] != v)
v = id[v];
return v;
}
}
| [
"[email protected]"
] | |
4748fa134bfec170255bb9e0a1e8a77589c1dd07 | 2b6e3a34ec277f72a5da125afecfe3f4a61419f5 | /Ruyicai_91/v3.4/src/com/ruyicai/activity/notice/LotnoDetail/QXCDetailView.java | cb24202a2b0f196fc4421137b7ffa09b36a53072 | [] | no_license | surport/Android | 03d538fe8484b0ff0a83b8b0b2499ad14592c64b | afc2668728379caeb504c9b769011f2ba1e27d25 | refs/heads/master | 2020-04-02T10:29:40.438348 | 2013-12-18T09:55:42 | 2013-12-18T09:55:42 | 15,285,717 | 3 | 5 | null | null | null | null | UTF-8 | Java | false | false | 5,315 | java | package com.ruyicai.activity.notice.LotnoDetail;
import org.json.JSONException;
import org.json.JSONObject;
import com.palmdream.RuyicaiAndroid91.R;
import com.ruyicai.activity.notice.PrizeBallLinearLayout;
import com.ruyicai.constant.Constants;
import com.ruyicai.net.newtransaction.NoticePrizeDetailInterface;
import com.ruyicai.util.PublicMethod;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.Handler;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
public class QXCDetailView extends LotnoDetailView{
public QXCDetailView(Activity context, String lotno, String batchcode,ProgressDialog progress,Handler handler,boolean isDialog) {
super(context, lotno, batchcode,progress,handler, isDialog);
// TODO Auto-generated constructor stub
}
TextView prizeBatchCode,prizeDate,totalsellmoney,prizepoolmoney;
TextView prizename1,prizenum1,prizemoney1;
TextView prizename2,prizenum2,prizemoney2;
TextView prizename3,prizenum3,prizemoney3;
TextView prizename4,prizenum4,prizemoney4;
TextView prizename5,prizenum5,prizemoney5;
TextView prizename6,prizenum6,prizemoney6;
@Override
void initLotnoDetailViewWidget() {
prizeBatchCode = (TextView)view.findViewById(R.id.prizedetail_batchcode);
prizeDate = (TextView)view.findViewById(R.id.prizedetail_prizeData);
ballLinear = (LinearLayout)view.findViewById(R.id.prizedetail_numball);
totalsellmoney = (TextView)view.findViewById(R.id.prizedetail_totalsellmoney);
prizepoolmoney = (TextView)view.findViewById(R.id.prizedetail_prizepoolmoney);
prizename1 = (TextView)view.findViewById(R.id.prizedetail_prizename1);
prizename2 = (TextView)view.findViewById(R.id.prizedetail_prizename2);
prizename3 = (TextView)view.findViewById(R.id.prizedetail_prizename3);
prizename4 = (TextView)view.findViewById(R.id.prizedetail_prizename4);
prizename5 = (TextView)view.findViewById(R.id.prizedetail_prizename5);
prizename6 = (TextView)view.findViewById(R.id.prizedetail_prizename6);
prizenum1 = (TextView)view.findViewById(R.id.prizedetail_prizenum1);
prizenum2 = (TextView)view.findViewById(R.id.prizedetail_prizenum2);
prizenum3 = (TextView)view.findViewById(R.id.prizedetail_prizenum3);
prizenum4 = (TextView)view.findViewById(R.id.prizedetail_prizenum4);
prizenum5 = (TextView)view.findViewById(R.id.prizedetail_prizenum5);
prizenum6 = (TextView)view.findViewById(R.id.prizedetail_prizenum6);
prizemoney1 =(TextView)view.findViewById(R.id.prizedetail_prizemoney1);
prizemoney2 =(TextView)view.findViewById(R.id.prizedetail_prizemoney2);
prizemoney3 =(TextView)view.findViewById(R.id.prizedetail_prizemoney3);
prizemoney4 =(TextView)view.findViewById(R.id.prizedetail_prizemoney4);
prizemoney5 =(TextView)view.findViewById(R.id.prizedetail_prizemoney5);
prizemoney6 =(TextView)view.findViewById(R.id.prizedetail_prizemoney6);
prizename1.setText(R.string.prizedetail_fristprize);
prizename2.setText(R.string.prizedetail_secondprize);
prizename3.setText(R.string.prizedetail_thirdprize);
prizename4.setText(R.string.prizedetail_fourthprize);
prizename5.setText(R.string.prizedetail_fifthprize);
prizename6.setText(R.string.prizedetail_sixthprize);
}
@Override
public void initLotonoView(JSONObject ssqPrizeDetailJson) throws JSONException {
// TODO Auto-generated method stub
prizeBatchCode.setText("七星彩 第"+ssqPrizeDetailJson.getString("batchCode")+"期");
prizeDate.setText(context.getString(R.string.prizedetail_opentime)+ssqPrizeDetailJson.getString("openTime"));
String prizeNum = ssqPrizeDetailJson.getString("winNo");
PrizeBallLinearLayout prizeBallLinear = new PrizeBallLinearLayout(context, ballLinear, Constants.QXCLABEL, prizeNum);
prizeBallLinear.initQXCBallLinear();
totalsellmoney.setText(context.getString(R.string.prizedetail_thebatchcodeamt)+PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("sellTotalAmount"))+context.getString(R.string.game_card_yuan));
prizepoolmoney.setText(context.getString(R.string.prizedetail_theprizepoolamt)+PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("prizePoolTotalAmount"))+context.getString(R.string.game_card_yuan));
prizenum1.setText(ssqPrizeDetailJson.getString("onePrizeNum"));
prizenum2.setText(ssqPrizeDetailJson.getString("twoPrizeNum"));
prizenum3.setText(ssqPrizeDetailJson.getString("threePrizeNum"));
prizenum4.setText(ssqPrizeDetailJson.getString("fourPrizeNum"));
prizenum5.setText(ssqPrizeDetailJson.getString("fivePrizeNum"));
prizenum6.setText(ssqPrizeDetailJson.getString("sixPrizeNum"));
prizemoney1.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("onePrizeAmt")));
prizemoney2.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("twoPrizeAmt")));
prizemoney3.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("threePrizeAmt")));
prizemoney4.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("fourPrizeAmt")));
prizemoney5.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("fivePrizeAmt")));
prizemoney6.setText(PublicMethod.toIntYuan(ssqPrizeDetailJson.getString("sixPrizeAmt")));
}
}
| [
"[email protected]"
] | |
205ddd38bbc46d0f522a6728a603c57057fcb574 | 7b5c4037d654c803fc2fc53a61cd664226b1d56b | /RIS/antlr/sparql/SparqlParserBaseListener.java | 8b66ae5c6ce3cb1be26591c278847a1b298332c7 | [] | no_license | UMKC-BigDataLab/RIQ | edcfd4102f9f9323d45f28963e62faf6d4f6f8c0 | 53bdf6cc800a62fa33233fb6e97c2314d3555de0 | refs/heads/master | 2021-01-10T15:24:02.636480 | 2020-06-26T14:59:39 | 2020-06-26T14:59:39 | 36,507,403 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 52,026 | java | // Generated from SparqlParser.g4 by ANTLR 4.4
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.misc.NotNull;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
/**
* This class provides an empty implementation of {@link SparqlParserListener},
* which can be extended to create a listener which only needs to handle a subset
* of the available methods.
*/
public class SparqlParserBaseListener implements SparqlParserListener {
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuadPattern(@NotNull SparqlParser.QuadPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuadPattern(@NotNull SparqlParser.QuadPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnaryMultiplicativeExpression(@NotNull SparqlParser.UnaryMultiplicativeExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnaryMultiplicativeExpression(@NotNull SparqlParser.UnaryMultiplicativeExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterAggregate(@NotNull SparqlParser.AggregateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitAggregate(@NotNull SparqlParser.AggregateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUpdateCommand(@NotNull SparqlParser.UpdateCommandContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUpdateCommand(@NotNull SparqlParser.UpdateCommandContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterLimitOffsetClauses(@NotNull SparqlParser.LimitOffsetClausesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitLimitOffsetClauses(@NotNull SparqlParser.LimitOffsetClausesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterArgList(@NotNull SparqlParser.ArgListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitArgList(@NotNull SparqlParser.ArgListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVerbPath(@NotNull SparqlParser.VerbPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVerbPath(@NotNull SparqlParser.VerbPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPrefixDecl(@NotNull SparqlParser.PrefixDeclContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPrefixDecl(@NotNull SparqlParser.PrefixDeclContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterExpressionList(@NotNull SparqlParser.ExpressionListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitExpressionList(@NotNull SparqlParser.ExpressionListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterCollectionPath(@NotNull SparqlParser.CollectionPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitCollectionPath(@NotNull SparqlParser.CollectionPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesTemplate(@NotNull SparqlParser.TriplesTemplateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesTemplate(@NotNull SparqlParser.TriplesTemplateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInlineData(@NotNull SparqlParser.InlineDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInlineData(@NotNull SparqlParser.InlineDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSelectVariables(@NotNull SparqlParser.SelectVariablesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSelectVariables(@NotNull SparqlParser.SelectVariablesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSolutionModifier(@NotNull SparqlParser.SolutionModifierContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSolutionModifier(@NotNull SparqlParser.SolutionModifierContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterOrderCondition(@NotNull SparqlParser.OrderConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitOrderCondition(@NotNull SparqlParser.OrderConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphOrDefault(@NotNull SparqlParser.GraphOrDefaultContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphOrDefault(@NotNull SparqlParser.GraphOrDefaultContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterMove(@NotNull SparqlParser.MoveContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitMove(@NotNull SparqlParser.MoveContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterCopy(@NotNull SparqlParser.CopyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitCopy(@NotNull SparqlParser.CopyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPrefixedName(@NotNull SparqlParser.PrefixedNameContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPrefixedName(@NotNull SparqlParser.PrefixedNameContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConstructQuery(@NotNull SparqlParser.ConstructQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConstructQuery(@NotNull SparqlParser.ConstructQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterStrReplaceExpression(@NotNull SparqlParser.StrReplaceExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitStrReplaceExpression(@NotNull SparqlParser.StrReplaceExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupGraphPatternSub(@NotNull SparqlParser.GroupGraphPatternSubContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupGraphPatternSub(@NotNull SparqlParser.GroupGraphPatternSubContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterObjectPath(@NotNull SparqlParser.ObjectPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitObjectPath(@NotNull SparqlParser.ObjectPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphRef(@NotNull SparqlParser.GraphRefContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphRef(@NotNull SparqlParser.GraphRefContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBuiltInCall(@NotNull SparqlParser.BuiltInCallContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBuiltInCall(@NotNull SparqlParser.BuiltInCallContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSelectQuery(@NotNull SparqlParser.SelectQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSelectQuery(@NotNull SparqlParser.SelectQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterCreate(@NotNull SparqlParser.CreateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitCreate(@NotNull SparqlParser.CreateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVarOrIRI(@NotNull SparqlParser.VarOrIRIContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVarOrIRI(@NotNull SparqlParser.VarOrIRIContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuadsNotTriples(@NotNull SparqlParser.QuadsNotTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuadsNotTriples(@NotNull SparqlParser.QuadsNotTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterHavingCondition(@NotNull SparqlParser.HavingConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitHavingCondition(@NotNull SparqlParser.HavingConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConstructTriples(@NotNull SparqlParser.ConstructTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConstructTriples(@NotNull SparqlParser.ConstructTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterServiceGraphPattern(@NotNull SparqlParser.ServiceGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitServiceGraphPattern(@NotNull SparqlParser.ServiceGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterLoad(@NotNull SparqlParser.LoadContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitLoad(@NotNull SparqlParser.LoadContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphNodePath(@NotNull SparqlParser.GraphNodePathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphNodePath(@NotNull SparqlParser.GraphNodePathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDeleteClause(@NotNull SparqlParser.DeleteClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDeleteClause(@NotNull SparqlParser.DeleteClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupOrUnionGraphPattern(@NotNull SparqlParser.GroupOrUnionGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupOrUnionGraphPattern(@NotNull SparqlParser.GroupOrUnionGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterRdfLiteral(@NotNull SparqlParser.RdfLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitRdfLiteral(@NotNull SparqlParser.RdfLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuery(@NotNull SparqlParser.QueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuery(@NotNull SparqlParser.QueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphTerm(@NotNull SparqlParser.GraphTermContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphTerm(@NotNull SparqlParser.GraphTermContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuadsDetails(@NotNull SparqlParser.QuadsDetailsContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuadsDetails(@NotNull SparqlParser.QuadsDetailsContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSubSelect(@NotNull SparqlParser.SubSelectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSubSelect(@NotNull SparqlParser.SubSelectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConstraint(@NotNull SparqlParser.ConstraintContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConstraint(@NotNull SparqlParser.ConstraintContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterCollection(@NotNull SparqlParser.CollectionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitCollection(@NotNull SparqlParser.CollectionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterHavingClause(@NotNull SparqlParser.HavingClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitHavingClause(@NotNull SparqlParser.HavingClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterClear(@NotNull SparqlParser.ClearContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitClear(@NotNull SparqlParser.ClearContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesBlock(@NotNull SparqlParser.TriplesBlockContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesBlock(@NotNull SparqlParser.TriplesBlockContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathMod(@NotNull SparqlParser.PathModContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathMod(@NotNull SparqlParser.PathModContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterOrderClause(@NotNull SparqlParser.OrderClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitOrderClause(@NotNull SparqlParser.OrderClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupGraphPattern(@NotNull SparqlParser.GroupGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupGraphPattern(@NotNull SparqlParser.GroupGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuadData(@NotNull SparqlParser.QuadDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuadData(@NotNull SparqlParser.QuadDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBaseExpression(@NotNull SparqlParser.BaseExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBaseExpression(@NotNull SparqlParser.BaseExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUsingClause(@NotNull SparqlParser.UsingClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUsingClause(@NotNull SparqlParser.UsingClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNumericLiteralPositive(@NotNull SparqlParser.NumericLiteralPositiveContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNumericLiteralPositive(@NotNull SparqlParser.NumericLiteralPositiveContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNumericLiteral(@NotNull SparqlParser.NumericLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNumericLiteral(@NotNull SparqlParser.NumericLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterIriRefOrFunction(@NotNull SparqlParser.IriRefOrFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitIriRefOrFunction(@NotNull SparqlParser.IriRefOrFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDataBlockValue(@NotNull SparqlParser.DataBlockValueContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDataBlockValue(@NotNull SparqlParser.DataBlockValueContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterRelationalSetExpression(@NotNull SparqlParser.RelationalSetExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitRelationalSetExpression(@NotNull SparqlParser.RelationalSetExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphNode(@NotNull SparqlParser.GraphNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphNode(@NotNull SparqlParser.GraphNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphRefAll(@NotNull SparqlParser.GraphRefAllContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphRefAll(@NotNull SparqlParser.GraphRefAllContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInteger(@NotNull SparqlParser.IntegerContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInteger(@NotNull SparqlParser.IntegerContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInlineDataFull(@NotNull SparqlParser.InlineDataFullContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInlineDataFull(@NotNull SparqlParser.InlineDataFullContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBooleanLiteral(@NotNull SparqlParser.BooleanLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBooleanLiteral(@NotNull SparqlParser.BooleanLiteralContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNumericLiteralUnsigned(@NotNull SparqlParser.NumericLiteralUnsignedContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNumericLiteralUnsigned(@NotNull SparqlParser.NumericLiteralUnsignedContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnarySignedLiteralExpression(@NotNull SparqlParser.UnarySignedLiteralExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnarySignedLiteralExpression(@NotNull SparqlParser.UnarySignedLiteralExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterOffsetClause(@NotNull SparqlParser.OffsetClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitOffsetClause(@NotNull SparqlParser.OffsetClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathElt(@NotNull SparqlParser.PathEltContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathElt(@NotNull SparqlParser.PathEltContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInlineDataOneVar(@NotNull SparqlParser.InlineDataOneVarContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInlineDataOneVar(@NotNull SparqlParser.InlineDataOneVarContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterAskQuery(@NotNull SparqlParser.AskQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitAskQuery(@NotNull SparqlParser.AskQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNotExistsFunction(@NotNull SparqlParser.NotExistsFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNotExistsFunction(@NotNull SparqlParser.NotExistsFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterString(@NotNull SparqlParser.StringContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitString(@NotNull SparqlParser.StringContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBlankNodePropertyListPath(@NotNull SparqlParser.BlankNodePropertyListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBlankNodePropertyListPath(@NotNull SparqlParser.BlankNodePropertyListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterMinusGraphPattern(@NotNull SparqlParser.MinusGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitMinusGraphPattern(@NotNull SparqlParser.MinusGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterExistsFunction(@NotNull SparqlParser.ExistsFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitExistsFunction(@NotNull SparqlParser.ExistsFunctionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterWhereClause(@NotNull SparqlParser.WhereClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitWhereClause(@NotNull SparqlParser.WhereClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphGraphPattern(@NotNull SparqlParser.GraphGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphGraphPattern(@NotNull SparqlParser.GraphGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterLimitClause(@NotNull SparqlParser.LimitClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitLimitClause(@NotNull SparqlParser.LimitClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPropertyListNotEmpty(@NotNull SparqlParser.PropertyListNotEmptyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPropertyListNotEmpty(@NotNull SparqlParser.PropertyListNotEmptyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnaryExpression(@NotNull SparqlParser.UnaryExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnaryExpression(@NotNull SparqlParser.UnaryExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDrop(@NotNull SparqlParser.DropContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDrop(@NotNull SparqlParser.DropContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBaseDecl(@NotNull SparqlParser.BaseDeclContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBaseDecl(@NotNull SparqlParser.BaseDeclContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPropertyList(@NotNull SparqlParser.PropertyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPropertyList(@NotNull SparqlParser.PropertyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInsertClause(@NotNull SparqlParser.InsertClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInsertClause(@NotNull SparqlParser.InsertClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPrimaryExpression(@NotNull SparqlParser.PrimaryExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPrimaryExpression(@NotNull SparqlParser.PrimaryExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnaryNegationExpression(@NotNull SparqlParser.UnaryNegationExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnaryNegationExpression(@NotNull SparqlParser.UnaryNegationExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterInsertData(@NotNull SparqlParser.InsertDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitInsertData(@NotNull SparqlParser.InsertDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathNegatedPropertySet(@NotNull SparqlParser.PathNegatedPropertySetContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathNegatedPropertySet(@NotNull SparqlParser.PathNegatedPropertySetContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSelectClause(@NotNull SparqlParser.SelectClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSelectClause(@NotNull SparqlParser.SelectClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterObjectListPath(@NotNull SparqlParser.ObjectListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitObjectListPath(@NotNull SparqlParser.ObjectListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterSubStringExpression(@NotNull SparqlParser.SubStringExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitSubStringExpression(@NotNull SparqlParser.SubStringExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterFunctionCall(@NotNull SparqlParser.FunctionCallContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitFunctionCall(@NotNull SparqlParser.FunctionCallContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterAnon(@NotNull SparqlParser.AnonContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitAnon(@NotNull SparqlParser.AnonContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesSameSubjectPath(@NotNull SparqlParser.TriplesSameSubjectPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesSameSubjectPath(@NotNull SparqlParser.TriplesSameSubjectPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnaryAdditiveExpression(@NotNull SparqlParser.UnaryAdditiveExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnaryAdditiveExpression(@NotNull SparqlParser.UnaryAdditiveExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVerbSimple(@NotNull SparqlParser.VerbSimpleContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVerbSimple(@NotNull SparqlParser.VerbSimpleContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDescribeQuery(@NotNull SparqlParser.DescribeQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDescribeQuery(@NotNull SparqlParser.DescribeQueryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesSameSubject(@NotNull SparqlParser.TriplesSameSubjectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesSameSubject(@NotNull SparqlParser.TriplesSameSubjectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPrologue(@NotNull SparqlParser.PrologueContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPrologue(@NotNull SparqlParser.PrologueContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConditionalAndExpression(@NotNull SparqlParser.ConditionalAndExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConditionalAndExpression(@NotNull SparqlParser.ConditionalAndExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNumericLiteralNegative(@NotNull SparqlParser.NumericLiteralNegativeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNumericLiteralNegative(@NotNull SparqlParser.NumericLiteralNegativeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterAdditiveExpression(@NotNull SparqlParser.AdditiveExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitAdditiveExpression(@NotNull SparqlParser.AdditiveExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupCondition(@NotNull SparqlParser.GroupConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupCondition(@NotNull SparqlParser.GroupConditionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterQuads(@NotNull SparqlParser.QuadsContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitQuads(@NotNull SparqlParser.QuadsContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDataBlock(@NotNull SparqlParser.DataBlockContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDataBlock(@NotNull SparqlParser.DataBlockContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBlankNode(@NotNull SparqlParser.BlankNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBlankNode(@NotNull SparqlParser.BlankNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesNodePath(@NotNull SparqlParser.TriplesNodePathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesNodePath(@NotNull SparqlParser.TriplesNodePathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPropertyListPath(@NotNull SparqlParser.PropertyListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPropertyListPath(@NotNull SparqlParser.PropertyListPathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupClause(@NotNull SparqlParser.GroupClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupClause(@NotNull SparqlParser.GroupClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDataBlockValues(@NotNull SparqlParser.DataBlockValuesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDataBlockValues(@NotNull SparqlParser.DataBlockValuesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConstructTemplate(@NotNull SparqlParser.ConstructTemplateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConstructTemplate(@NotNull SparqlParser.ConstructTemplateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterFilter(@NotNull SparqlParser.FilterContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitFilter(@NotNull SparqlParser.FilterContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterMultiplicativeExpression(@NotNull SparqlParser.MultiplicativeExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitMultiplicativeExpression(@NotNull SparqlParser.MultiplicativeExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUpdate(@NotNull SparqlParser.UpdateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUpdate(@NotNull SparqlParser.UpdateContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVarOrTerm(@NotNull SparqlParser.VarOrTermContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVarOrTerm(@NotNull SparqlParser.VarOrTermContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVar(@NotNull SparqlParser.VarContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVar(@NotNull SparqlParser.VarContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDeleteWhere(@NotNull SparqlParser.DeleteWhereContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDeleteWhere(@NotNull SparqlParser.DeleteWhereContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterRegexExpression(@NotNull SparqlParser.RegexExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitRegexExpression(@NotNull SparqlParser.RegexExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterTriplesNode(@NotNull SparqlParser.TriplesNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitTriplesNode(@NotNull SparqlParser.TriplesNodeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathPrimary(@NotNull SparqlParser.PathPrimaryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathPrimary(@NotNull SparqlParser.PathPrimaryContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterObjectList(@NotNull SparqlParser.ObjectListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitObjectList(@NotNull SparqlParser.ObjectListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterObject(@NotNull SparqlParser.ObjectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitObject(@NotNull SparqlParser.ObjectContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterAdd(@NotNull SparqlParser.AddContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitAdd(@NotNull SparqlParser.AddContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterIri(@NotNull SparqlParser.IriContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitIri(@NotNull SparqlParser.IriContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathSequence(@NotNull SparqlParser.PathSequenceContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathSequence(@NotNull SparqlParser.PathSequenceContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGroupGraphPatternSubList(@NotNull SparqlParser.GroupGraphPatternSubListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGroupGraphPatternSubList(@NotNull SparqlParser.GroupGraphPatternSubListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathEltOrInverse(@NotNull SparqlParser.PathEltOrInverseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathEltOrInverse(@NotNull SparqlParser.PathEltOrInverseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterVerb(@NotNull SparqlParser.VerbContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitVerb(@NotNull SparqlParser.VerbContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterOptionalGraphPattern(@NotNull SparqlParser.OptionalGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitOptionalGraphPattern(@NotNull SparqlParser.OptionalGraphPatternContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterRelationalExpression(@NotNull SparqlParser.RelationalExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitRelationalExpression(@NotNull SparqlParser.RelationalExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterValuesClause(@NotNull SparqlParser.ValuesClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitValuesClause(@NotNull SparqlParser.ValuesClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBlankNodePropertyList(@NotNull SparqlParser.BlankNodePropertyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBlankNodePropertyList(@NotNull SparqlParser.BlankNodePropertyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPath(@NotNull SparqlParser.PathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPath(@NotNull SparqlParser.PathContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterConditionalOrExpression(@NotNull SparqlParser.ConditionalOrExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitConditionalOrExpression(@NotNull SparqlParser.ConditionalOrExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDatasetClause(@NotNull SparqlParser.DatasetClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDatasetClause(@NotNull SparqlParser.DatasetClauseContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterDeleteData(@NotNull SparqlParser.DeleteDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitDeleteData(@NotNull SparqlParser.DeleteDataContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterModify(@NotNull SparqlParser.ModifyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitModify(@NotNull SparqlParser.ModifyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterGraphPatternNotTriples(@NotNull SparqlParser.GraphPatternNotTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitGraphPatternNotTriples(@NotNull SparqlParser.GraphPatternNotTriplesContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterUnaryLiteralExpression(@NotNull SparqlParser.UnaryLiteralExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitUnaryLiteralExpression(@NotNull SparqlParser.UnaryLiteralExpressionContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPropertyListPathNotEmptyList(@NotNull SparqlParser.PropertyListPathNotEmptyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPropertyListPathNotEmptyList(@NotNull SparqlParser.PropertyListPathNotEmptyListContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathOneInPropertySet(@NotNull SparqlParser.PathOneInPropertySetContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathOneInPropertySet(@NotNull SparqlParser.PathOneInPropertySetContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPathAlternative(@NotNull SparqlParser.PathAlternativeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPathAlternative(@NotNull SparqlParser.PathAlternativeContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterBind(@NotNull SparqlParser.BindContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitBind(@NotNull SparqlParser.BindContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterPropertyListPathNotEmpty(@NotNull SparqlParser.PropertyListPathNotEmptyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitPropertyListPathNotEmpty(@NotNull SparqlParser.PropertyListPathNotEmptyContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterNil(@NotNull SparqlParser.NilContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitNil(@NotNull SparqlParser.NilContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void enterEveryRule(@NotNull ParserRuleContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void exitEveryRule(@NotNull ParserRuleContext ctx) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void visitTerminal(@NotNull TerminalNode node) { }
/**
* {@inheritDoc}
*
* <p>The default implementation does nothing.</p>
*/
@Override public void visitErrorNode(@NotNull ErrorNode node) { }
} | [
"[email protected]"
] | |
8e2bc574fafae5376b2e0d73590ea8cf3770e29b | 577ed98a028936bef4b98f8e33974ee31046f406 | /keep_it_up_/src/br/com/keepitup/service/AlunoService.java | e10898edaac439996d33e9a1c8c97e5685707b83 | [] | no_license | lucasfealves/keep_up_it | a06fc1b8155285775725d9698621e88dc1918de0 | 497ed0f9957feb3b7ec1a4c172d5e48606c7ab68 | refs/heads/master | 2021-01-25T09:14:29.904514 | 2017-06-20T23:29:13 | 2017-06-20T23:29:13 | 93,800,645 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 455 | java | package br.com.keepitup.service;
import br.com.keepitup.dao.FactoryDao;
import br.com.keepitup.dao.InterfaceDao;
import br.com.keepitup.entity.Aluno;
public class AlunoService {
public void salvar(Aluno a) throws ServiceException {
if (a.getIdade() < 15) {
throw new ServiceException("RN01 - A idade deve ser maior que 15");
}
InterfaceDao<Aluno> daoAluno =
FactoryDao.createAlunoDao();
daoAluno.salvar(a);
}
}
| [
"Lucas@LUCASFEALVES"
] | Lucas@LUCASFEALVES |
f7f2a5cef3e4e6037a5b30355551986b315c0b8c | 641035da61315e461a7d10756143cc9edfacc48d | /QuadraticEquation/src/CalculateRoots.java | 036f715dc7ed269766019af2a0496b65d237e4d1 | [] | no_license | phobx/workspace | 483821c3b0edcfa20187096d481a6d96f6f46926 | caf1464dc7be8e198d9a460bf9809ac50c1a5107 | refs/heads/master | 2021-01-01T06:33:33.245931 | 2015-03-15T13:28:00 | 2015-03-15T13:28:00 | 26,287,507 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 660 | java | public class CalculateRoots {
public static void main(String[] args) {
double a = 1;
double b = 2;
double c = 5;
System.out.println("\na = " + a + "; b = " + b + "; c = " + c + ";");
QE.printRoots(QE.solveQE(a, b, c));
a = 0;
b = 2;
c = -6;
System.out.println("\na = " + a + "; b = " + b + "; c = " + c + ";");
QE.printRoots(QE.solveQE(a, b, c));
a = -1;
b = 2;
c = -5;
System.out.println("\na = " + a + "; b = " + b + "; c = " + c + ";");
QE.printRoots(QE.solveQE(a, b, c));
a = -1.5;
b = 2;
c = 10;
System.out.println("\na = " + a + "; b = " + b + "; c = " + c + ";");
QE.printRoots(QE.solveQE(a, b, c));
}
}
| [
"[email protected]"
] | |
fee6530ea97cd769368ac342c032f3b8bf25e443 | 31a37ca53d4ad8edb575cb858495b2efc891c54a | /MySPA_Desktop/myspa_desktop/src/org/solsistemas/myspa/desktop_app/gui/PanelSucursal.java | 94ffb4ae992b816d6327c638716b52738e4922af | [] | no_license | SystemKeys/MYSPA_application | c7f3f510edc7a321bf261fc13b394a3853a05199 | c43570af2c8207bf4fe6a20a37d6f2047b18418a | refs/heads/master | 2020-04-02T03:34:54.912965 | 2018-12-04T01:20:48 | 2018-12-04T01:20:48 | 153,973,722 | 0 | 1 | null | 2018-11-02T03:38:13 | 2018-10-21T04:35:54 | JavaScript | UTF-8 | Java | false | false | 9,188 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package org.solsistemas.myspa.desktop_app.gui;
import java.util.List;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.control.Alert;
import javafx.scene.control.Button;
import javafx.scene.control.CheckBox;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Modality;
import javafx.stage.Stage;
import org.solsistemas.myspa.controller.ControllerSucursal;
import org.solsistemas.myspa.model.Sucursal;
import org.solsistemas.myspa.desktop_app.gui.components.TableAdapterSucursal;
/**
*
* @author Vanessa
*/
public class PanelSucursal {
Stage window;
@FXML AnchorPane panelRaiz;
@FXML TextField txtId;
@FXML TextField txtNombre;
@FXML TextField txtLatitud;
@FXML TextField txtLongitud;
@FXML TextField txtDomicilio;
@FXML TextField txtRef;
@FXML CheckBox chbActivo;
@FXML CheckBox chbInactivo;
@FXML Button btnGuardar;
@FXML Button btnEliminar;
@FXML Button btnNuevo;
@FXML Button btnConsultar;
@FXML Button btnBuscar;
@FXML TableView<Sucursal> tblSucursales;
FXMLLoader fxmll;
ControllerSucursal cs;
public PanelSucursal(Stage ventanaApp){
window = ventanaApp;
fxmll = new FXMLLoader(System.class.getResource("/org/solsistemas/myspa/desktop_app/gui/fxml/panel_sucursal.fxml"));
fxmll.setController(this);
}
public void inicializar() throws Exception{
//Primero instanciamos el controlador de sucursales:
cs = new ControllerSucursal();
//Después cargamos el archivo fxml:
fxmll.load();
TableAdapterSucursal.adapt(tblSucursales);
//Agregamos oyentes:
agregarOyentes();
}
private void guardarSucursal(){
int idGenerado = 0;
Sucursal s = new Sucursal();
try{
//p.setEstatus(chbActivo.isSelected() ? 1 : 0);
if(chbActivo.isSelected())
s.setEstatus(1);
else
s.setEstatus(0);
//Si la caja de texto NO esta vacía:
if(!txtId.getText().isEmpty())
s.setId(Integer.valueOf(txtId.getText()));
s.setNombre(txtNombre.getText());
s.setDomicilio(txtDomicilio.getText());
s.setLatitud(Double.valueOf(txtLatitud.getText()));
s.setLongitud(Double.valueOf(txtLongitud.getText()));
if(s.getId() == 0){
idGenerado = cs.insert(s);
txtId.setText("" + idGenerado);
tblSucursales.getItems().add(s);
}else
cs.update(s);
mostrarMensaje( "Movimiento realizado.",
"Datos de la sucursal guardados correctamente.",
Alert.AlertType.CONFIRMATION);
}catch(Exception e){
e.printStackTrace();
mostrarMensaje( "Error al persistir datos.",
"Ocurrió el siguiente error: " + e.toString(),
Alert.AlertType.ERROR);
}
}
private void consultarSucursales(){
List<Sucursal> listaSucursales = null;
ObservableList<Sucursal> listaObservableSucursales = null;
try{
//Consultamos las sucursales a través del
//ControllerSucursal:
if(chbInactivo.isSelected()){
listaSucursales = cs.getAll("",0);
}else{
listaSucursales = cs.getAll("",1);
}
//Convertimos nuestra lista de sucursales en una
//lista Observable de sucursales:
listaObservableSucursales = FXCollections.observableArrayList(listaSucursales);
//Ponemos la lista observable dentro del table view
tblSucursales.setItems(listaObservableSucursales);
}catch(Exception e){
e.printStackTrace();
mostrarMensaje( "Error",
"Ocurrio el siguiente error: " + e.toString(),
Alert.AlertType.ERROR);
}
}
private void mostrarDetalleSucursal(){
Sucursal s = tblSucursales.getSelectionModel().getSelectedItem();
if(s != null){
txtId.setText("" + s.getId());
txtNombre.setText("" + s.getNombre());
txtDomicilio.setText("" + s.getDomicilio());
txtLongitud.setText("" +s.getLongitud());
txtLatitud.setText("" +s.getLatitud());
if(s.getEstatus() == 1){
chbActivo.setSelected(true);
}else{
chbActivo.setSelected(false);
}
}
}
private void eliminarSucursal(){
Sucursal s = new Sucursal();
try{
if(! txtId.getText().isEmpty()){
s.setId(Integer.valueOf(txtId.getText()));
s.setNombre(txtNombre.getText());
s.setDomicilio(txtDomicilio.getText());
s.setLatitud(Double.valueOf(txtLatitud.getText()));
s.setLongitud(Double.valueOf(txtLongitud.getText()));
if(chbActivo.isSelected()){
s.setEstatus(1);
}else{
s.setEstatus(0);
}
cs.delete(s.getId());
s = tblSucursales.getSelectionModel().getSelectedItem();
tblSucursales.getItems().remove(s);
limpiarPanel();
mostrarMensaje( "Movimiento realizado.",
"Datos de sucursal eliminados correctamente.",
Alert.AlertType.CONFIRMATION);
}
}catch(Exception e){
e.printStackTrace();
mostrarMensaje( "Error al eliminar datos.",
"Ocurrió el siguiente error: " + e.toString(),
Alert.AlertType.ERROR);
}
}
private void limpiarPanel(){
txtNombre.setText("");
txtDomicilio.setText("");
txtId.setText("");
txtLongitud.setText("");
txtLatitud.setText("");
chbActivo.setSelected(false);
}
private void buscarSucursal(){
Sucursal s = new Sucursal();
ObservableList<Sucursal> listaObservableSucursales = null;
try{
int i = Integer.valueOf(txtRef.getText());
s = cs.findById(i);
tblSucursales.getItems().clear();
listaObservableSucursales = FXCollections.observableArrayList(s);
//Ponemos la lista observable dentro del table view
tblSucursales.setItems(listaObservableSucursales);
}catch(Exception e){
e.printStackTrace();
mostrarMensaje( "Error al buscar datos.",
"Ocurrió el siguiente error: " + e.toString(),
Alert.AlertType.ERROR);
}
}
/**
* Este método es para mostrar un mensaje modal.
* @param titulo El título de la ventana.
* @param mensaje El contenido del mensaje.
* @param tipoMensaje El tipo de mensaje.
*/
private void mostrarMensaje(String titulo, String mensaje, Alert.AlertType tipoMensaje) {
//Creamos una nueva alerta:
Alert msg = new Alert(tipoMensaje);
//Establecemos el título de la ventana del mensaje:
msg.setTitle(titulo);
//Establecemos el contenido de la ventana del mensaje:
msg.setContentText(mensaje);
//Establecemos el tipo de la ventana del mensaje como MODAL.
//Esto significa que el programa no avanza hasta que el usuario realiza
//una acción que cierra la ventana:
msg.initModality(Modality.WINDOW_MODAL);
//Establecemos la ventana "Padre" de la ventana del mensaje:
msg.initOwner(window);
//Mostramos la ventana del mensaje y esperamos:
msg.showAndWait();
}
public void agregarOyentes(){
btnGuardar.setOnAction(evt -> { guardarSucursal(); });
btnEliminar.setOnAction(evt -> { eliminarSucursal(); });
btnNuevo.setOnAction(evt -> { limpiarPanel(); });
btnConsultar.setOnAction(evt -> { consultarSucursales(); });
btnBuscar.setOnAction(evt -> { buscarSucursal(); });
tblSucursales.getSelectionModel().selectedItemProperty().addListener(evt -> {mostrarDetalleSucursal();} );
}
}
| [
"[email protected]"
] | |
e7801ea3fb43cca73aaef45ffc80fe044e05e977 | b3c6ba6530753e7154098c4a33daa0a0b0de6c5a | /android/app/src/debug/java/com/savemydates/ReactNativeFlipper.java | 0ca82bd5881d4f3090b3c720aa06491c01520d1d | [] | no_license | Android-Club-VITC/SaveMyDates | fcc671eb507e3b2d1302eb70b39a477660e2cf99 | cea48d457c70a841a46353280fca4907fd456879 | refs/heads/main | 2023-06-29T09:59:39.333456 | 2021-08-05T04:12:36 | 2021-08-05T04:12:36 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,266 | java | /**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* <p>This source code is licensed under the MIT license found in the LICENSE file in the root
* directory of this source tree.
*/
package com.savemydates;
import android.content.Context;
import com.facebook.flipper.android.AndroidFlipperClient;
import com.facebook.flipper.android.utils.FlipperUtils;
import com.facebook.flipper.core.FlipperClient;
import com.facebook.flipper.plugins.crashreporter.CrashReporterPlugin;
import com.facebook.flipper.plugins.databases.DatabasesFlipperPlugin;
import com.facebook.flipper.plugins.fresco.FrescoFlipperPlugin;
import com.facebook.flipper.plugins.inspector.DescriptorMapping;
import com.facebook.flipper.plugins.inspector.InspectorFlipperPlugin;
import com.facebook.flipper.plugins.network.FlipperOkhttpInterceptor;
import com.facebook.flipper.plugins.network.NetworkFlipperPlugin;
import com.facebook.flipper.plugins.react.ReactFlipperPlugin;
import com.facebook.flipper.plugins.sharedpreferences.SharedPreferencesFlipperPlugin;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.modules.network.NetworkingModule;
import okhttp3.OkHttpClient;
public class ReactNativeFlipper {
public static void initializeFlipper(Context context, ReactInstanceManager reactInstanceManager) {
if (FlipperUtils.shouldEnableFlipper(context)) {
final FlipperClient client = AndroidFlipperClient.getInstance(context);
client.addPlugin(new InspectorFlipperPlugin(context, DescriptorMapping.withDefaults()));
client.addPlugin(new ReactFlipperPlugin());
client.addPlugin(new DatabasesFlipperPlugin(context));
client.addPlugin(new SharedPreferencesFlipperPlugin(context));
client.addPlugin(CrashReporterPlugin.getInstance());
NetworkFlipperPlugin networkFlipperPlugin = new NetworkFlipperPlugin();
NetworkingModule.setCustomClientBuilder(
new NetworkingModule.CustomClientBuilder() {
@Override
public void apply(OkHttpClient.Builder builder) {
builder.addNetworkInterceptor(new FlipperOkhttpInterceptor(networkFlipperPlugin));
}
});
client.addPlugin(networkFlipperPlugin);
client.start();
// Fresco Plugin needs to ensure that ImagePipelineFactory is initialized
// Hence we run if after all native modules have been initialized
ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
if (reactContext == null) {
reactInstanceManager.addReactInstanceEventListener(
new ReactInstanceManager.ReactInstanceEventListener() {
@Override
public void onReactContextInitialized(ReactContext reactContext) {
reactInstanceManager.removeReactInstanceEventListener(this);
reactContext.runOnNativeModulesQueueThread(
new Runnable() {
@Override
public void run() {
client.addPlugin(new FrescoFlipperPlugin());
}
});
}
});
} else {
client.addPlugin(new FrescoFlipperPlugin());
}
}
}
}
| [
"[email protected]"
] | |
a3e1108ba81f2cf7b6a44fff736ab0ee01817632 | 5bc1354da63a14eddafb33759ece02cd6bb50dd1 | /src/main/java/com/stepdefinition/TestRunner.java | 0a869e3211e741c223646092e5a3d3bf1f0697ea | [] | no_license | Ahamed17/BDD_Project_Team3 | fc8a04bd7a3d3b9241684159e746c12ac9750a8a | ad362b42ae82031dd52e6f85a0fda76ceac8e480 | refs/heads/master | 2021-08-22T03:52:30.141333 | 2017-11-29T06:11:05 | 2017-11-29T06:11:05 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,102 | java | package com.stepdefinition;
import java.io.File;
import org.joda.time.LocalDateTime;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import com.resources.ExtentCucumberFormatter;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;
@RunWith(Cucumber.class)
@CucumberOptions(features = "src/test/resources/com/Login", glue = { "com.stepdefinition" }, plugin = {
"com.resources.ExtentCucumberFormatter:" })
public class TestRunner {
@BeforeClass
public static void beforeClass() {
LocalDateTime now = LocalDateTime.now();
int year = now.getYear();
int month = now.getMonthOfYear();
int day = now.getDayOfMonth();
int hour = now.getHourOfDay();
int minute = now.getMinuteOfHour();
int second = now.getSecondOfMinute();
String snewFilename1 = year + "_" + month + "_" + day + "_" + hour + "_" + minute + "_" + second;
String filePath = System.getProperty("user.dir") + "\\src\\main\\resources\\AutomationSuite\\Report_"
+ snewFilename1 + ".html";
File file = new File(filePath);
ExtentCucumberFormatter.setExtentHtmlReport(file);
}
} | [
"[email protected]"
] | |
770b849e7106f418ab0af0d91ccf57405ff11051 | 5af1fb108e9fa5991ed875b65d46309ebf138ec8 | /klevu-data-etl/src/main/java/com/klevu/task/model/web/Error.java | fa353e682dec047d4ae45cd6390c5ef36d658b31 | [] | no_license | laplasianin/recommendation-micronaut | fc8886c2db31f07326a61fcc9e01f2353cf9a239 | 5e0e5af393cecf0fc11086692ce85a27945c4a6e | refs/heads/main | 2023-08-16T15:39:58.195727 | 2021-10-04T15:06:45 | 2021-10-04T15:06:45 | 413,390,320 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 236 | java | package com.klevu.task.model.web;
public class Error {
private final String code;
private final String message;
public Error(String code, String message) {
this.code = code;
this.message = message;
}
} | [
"[email protected]"
] | |
c01bde59338dc525cc45ef53509c5aa3dcacba9f | b145a18fdcf5e5c5ee039efaab8a6de4da99e95f | /src/software1/wgu/ui/modifyProduct/modifyProductLoader.java | 2f7d3157a84ac128ff80b7042bfd3f5d40c25c11 | [] | no_license | KhueHoang/Inventory-System | f762dded1758fcc76b68e6aa72894b884175419f | ed39f4d71754cf4a454831cef041292e1bd5cd3d | refs/heads/master | 2020-04-10T18:52:08.182950 | 2018-12-10T18:11:43 | 2018-12-10T18:11:43 | 161,215,284 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 984 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package software1.wgu.ui.modifyProduct;
import javafx.application.Application;
import static javafx.application.Application.launch;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
/**
*
* @author khue
*/
public class modifyProductLoader extends Application {
@Override
public void start(Stage stage) throws Exception {
Parent root = FXMLLoader.load(getClass().getResource("modifyProduct.fxml"));
Scene scene = new Scene(root);
stage.setScene(scene);
stage.show();
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}
} | [
"[email protected]"
] | |
bc957950b4ed89af864bfcc5ae952e4822de657f | 23a7445ec116d26823eeb1610c4d8dbe22f0b045 | /aTalk/src/main/java/net/java/sip/communicator/impl/protocol/jabber/extensions/jingle/PayloadTypePacketExtension.java | beac2d9793ffd49ea7c83f9f778e8203c1d3d12d | [
"Apache-2.0"
] | permissive | Rudloff/atalk-android | e998e9d1787f5aa4c08efb38b1607c0ebdfa52f3 | 00ff07475bf0233a60ddb6ad93bd0ba4be4f3572 | refs/heads/master | 2020-03-17T15:27:35.236473 | 2018-05-07T10:45:33 | 2018-05-07T10:45:33 | 133,711,522 | 1 | 0 | null | 2018-05-16T19:06:01 | 2018-05-16T19:06:00 | null | UTF-8 | Java | false | false | 6,231 | java | /*
* Jitsi, the OpenSource Java VoIP and Instant Messaging client.
*
* Distributable under LGPL license. See terms of license at gnu.org.
*/
package net.java.sip.communicator.impl.protocol.jabber.extensions.jingle;
import java.util.List;
import net.java.sip.communicator.impl.protocol.jabber.extensions.AbstractPacketExtension;
/**
* Represents the <tt>payload-type</tt> elements described in XEP-0167.
*
* @author Emil Ivov
* @author Eng Chong Meng
*/
public class PayloadTypePacketExtension extends AbstractPacketExtension
{
/**
* The name of the "payload-type" element.
*/
public static final String ELEMENT_NAME = "payload-type";
/**
* The name of the <tt>channels</tt> <tt>payload-type</tt> argument.
*/
public static final String CHANNELS_ATTR_NAME = "channels";
/**
* The name of the <tt>clockrate</tt> SDP argument.
*/
public static final String CLOCKRATE_ATTR_NAME = "clockrate";
/**
* The name of the payload <tt>id</tt> SDP argument.
*/
public static final String ID_ATTR_NAME = "id";
/**
* The name of the <tt>maxptime</tt> SDP argument.
*/
public static final String MAXPTIME_ATTR_NAME = "maxptime";
/**
* The name of the <tt>name</tt> SDP argument.
*/
public static final String NAME_ATTR_NAME = "name";
/**
* The name of the <tt>ptime</tt> SDP argument.
*/
public static final String PTIME_ATTR_NAME = "ptime";
/**
* Creates a new {@link PayloadTypePacketExtension} instance.
*/
public PayloadTypePacketExtension()
{
super(ELEMENT_NAME, null);
}
/**
* Sets the number of channels in this payload type. If omitted, it will be assumed to contain
* one channel.
*
* @param channels
* the number of channels in this payload type.
*/
public void setChannels(int channels)
{
super.setAttribute(CHANNELS_ATTR_NAME, channels);
}
/**
* Returns the number of channels in this payload type.
*
* @return the number of channels in this payload type.
*/
public int getChannels()
{
/*
* XEP-0167: Jingle RTP Sessions says: if omitted, it MUST be assumed to contain one
* channel.
*/
return getAttributeAsInt(CHANNELS_ATTR_NAME, 1);
}
/**
* Specifies the sampling frequency in Hertz used by this encoding.
*
* @param clockrate
* the sampling frequency in Hertz used by this encoding.
*/
public void setClockrate(int clockrate)
{
super.setAttribute(CLOCKRATE_ATTR_NAME, clockrate);
}
/**
* Returns the sampling frequency in Hertz used by this encoding.
*
* @return the sampling frequency in Hertz used by this encoding.
*/
public int getClockrate()
{
return getAttributeAsInt(CLOCKRATE_ATTR_NAME);
}
/**
* Specifies the payload identifier for this encoding.
*
* @param id
* the payload type id
*/
public void setId(int id)
{
super.setAttribute(ID_ATTR_NAME, id);
}
/**
* Returns the payload identifier for this encoding (as specified by RFC 3551 or a dynamic one).
*
* @return the payload identifier for this encoding (as specified by RFC 3551 or a dynamic one).
*/
public int getID()
{
return getAttributeAsInt(ID_ATTR_NAME);
}
/**
* Sets the maximum packet time as specified in RFC 4566.
*
* @param maxptime
* the maximum packet time as specified in RFC 4566
*/
public void setMaxptime(int maxptime)
{
setAttribute(MAXPTIME_ATTR_NAME, maxptime);
}
/**
* Returns maximum packet time as specified in RFC 4566.
*
* @return maximum packet time as specified in RFC 4566
*/
public int getMaxptime()
{
return getAttributeAsInt(MAXPTIME_ATTR_NAME);
}
/**
* Sets the packet time as specified in RFC 4566.
*
* @param ptime
* the packet time as specified in RFC 4566
*/
public void setPtime(int ptime)
{
super.setAttribute(PTIME_ATTR_NAME, ptime);
}
/**
* Returns packet time as specified in RFC 4566.
*
* @return packet time as specified in RFC 4566
*/
public int getPtime()
{
return getAttributeAsInt(PTIME_ATTR_NAME);
}
/**
* Sets the name of the encoding, or as per the XEP: the appropriate subtype of the MIME type.
* Setting this field is RECOMMENDED for static payload types, REQUIRED for dynamic payload
* types.
*
* @param name
* the name of this encoding.
*/
public void setName(String name)
{
setAttribute(NAME_ATTR_NAME, name);
}
/**
* Returns the name of the encoding, or as per the XEP: the appropriate subtype of the MIME
* type. Setting this field is RECOMMENDED for static payload types, REQUIRED for dynamic
* payload types.
*
* @return the name of the encoding, or as per the XEP: the appropriate subtype of the MIME
* type. Setting this field is RECOMMENDED for static payload types, REQUIRED for
* dynamic payload types.
*/
public String getName()
{
return getAttributeAsString(NAME_ATTR_NAME);
}
/**
* Adds an SDP parameter to the list that we already have registered for this payload type.
*
* @param parameter
* an SDP parameter for this encoding.
*/
public void addParameter(ParameterPacketExtension parameter)
{
// parameters are the only extensions we can have so let's use
// super's list.
addChildExtension(parameter);
}
/**
* Returns a <b>reference</b> to the the list of parameters currently registered for this
* payload type.
*
* @return a <b>reference</b> to the the list of parameters currently registered for this
* payload type.
*/
public List<ParameterPacketExtension> getParameters()
{
return getChildExtensionsOfType(ParameterPacketExtension.class);
}
/**
* Adds an RTCP feedback type to the list that we already have registered for this payload type.
*
* @param rtcpFbPacketExtension
* RTCP feedback type for this encoding.
*/
public void addRtcpFeedbackType(RtcpFbPacketExtension rtcpFbPacketExtension)
{
addChildExtension(rtcpFbPacketExtension);
}
/**
* Returns the list of RTCP feedback types currently registered for this payload type.
*
* @return the list of RTCP feedback types currently registered for this payload type.
*/
public List<RtcpFbPacketExtension> getRtcpFeedbackTypeList()
{
return getChildExtensionsOfType(RtcpFbPacketExtension.class);
}
}
| [
"[email protected]"
] | |
605195a4211655841b173298778bd296218bf85c | 22fb2b3aba450ddf4392a9670fa8b2a985e75cd0 | /src/ru/geekbrains/lesson6/Test.java | b2b8d977d344a98681a07bc36174ca4d9a63d53d | [] | no_license | aabasalov/lesson6 | 80fac1748d3d79db82a310966f8f90e4cddb7130 | 65f227d5117b11b5b3c4061aa932965840f061e3 | refs/heads/master | 2023-02-23T21:18:33.297279 | 2021-01-15T09:15:28 | 2021-01-15T09:15:28 | 329,863,522 | 0 | 0 | null | 2021-01-21T14:52:30 | 2021-01-15T09:15:29 | Java | UTF-8 | Java | false | false | 372 | java | package ru.geekbrains.lesson6;
public class Test {
public static void main(String[] args) {
Animal cat = new Cat("Remus", 3, "White", 200, 0, 2);
Animal dog = new Dog("Shuma",4 , "Black-white", 500, 10, 0.5);
Animal cat1 = new Cat("Pushistik", 5, "Grey", 200, 0, 2);
cat1.jump(5);
cat.swim(400);
dog.run(500);
}
}
| [
"[email protected]"
] | |
12bdb5d19195fc835e0d2771816a68699bc1a358 | d5b1ff99d731fd3069496b6e4c7dab79405e88e8 | /src/main/java/org/apache/ibatis/cache/decorators/LruCache.java | 6d59fad15ac167ee21b031fa4b0f0a1725b1d18c | [] | no_license | yangyangha/mb3.4.6 | dd41f862fd050748d373c1e3cf05689305cfe54f | 2b716a5b37ff24a29fb9242157bd1aca6e9af63f | refs/heads/master | 2022-06-30T14:04:55.067975 | 2020-04-16T00:42:18 | 2020-04-16T00:42:18 | 145,185,342 | 1 | 0 | null | 2022-06-29T19:17:53 | 2018-08-18T03:01:51 | Java | UTF-8 | Java | false | false | 3,800 | java | /**
* Copyright 2009-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* 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.ibatis.cache.decorators;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import org.apache.ibatis.cache.Cache;
/**
* done
* Lru 算法使用了linkedhashmap的数据结构
*
* Lru (least recently used) cache decorator
*
* @author Clinton Begin
*
*
* linkedhashmap 简单而言就是有序的hashmap
* LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。
* 默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。
*
* linkedlist 按插入顺序，但是没有key-value结构！
* https://www.cnblogs.com/whoislcj/p/5552421.html
* http://www.cnblogs.com/children/archive/2012/10/02/2710624.html
*
* 装填因子/加载因子/负载因子 α= 填入表中的元素个数 / 哈希表的长度
* 负载因子表示哈希表空间元素密度，越大表示哈希表越满，产生冲突的可能性越大
* 一般常用0.75
*
* todo:interview linkedhashmap 实现结构
*/
public class LruCache implements Cache {
private final Cache delegate;
//维护了第二份缓存，只是使用其lru算法，获取最老、最少使用的元素来删除delegate的元素；有点儿浪费了空间
private Map<Object, Object> keyMap;
private Object eldestKey;
public LruCache(Cache delegate) {
this.delegate = delegate;
setSize(1024);
}
@Override
public String getId() {
return delegate.getId();
}
@Override
public int getSize() {
return delegate.getSize();
}
public void setSize(final int size) {
keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
private static final long serialVersionUID = 4267176411845948333L;
//默认是返回false 即不会删除最老、使用最少的数据
@Override
protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
boolean tooBig = size() > size;
if (tooBig) {
eldestKey = eldest.getKey();
}
return tooBig;
}
};
}
@Override
public void putObject(Object key, Object value) {
delegate.putObject(key, value);
cycleKeyList(key);
}
@Override
public Object getObject(Object key) {
keyMap.get(key); //touch 增加一次访问，更新一次排序
return delegate.getObject(key);
}
@Override
public Object removeObject(Object key) {
return delegate.removeObject(key);
}
@Override
public void clear() {
delegate.clear();
keyMap.clear();
}
@Override
public ReadWriteLock getReadWriteLock() {
return null;
}
private void cycleKeyList(Object key) {
keyMap.put(key, key);
if (eldestKey != null) {
delegate.removeObject(eldestKey);
eldestKey = null;
}
}
}
| [
"[email protected]"
] | |
d61bdaff21b97cd5eb7d463a85a827c608b1de8b | beedf85752613903a82651b1b9a9963c19971699 | /Droid/app/src/main/java/com/mydesignerclothing/mobile/android/util/MyDSCAndroidUIUtils.java | 4b6e14e14474baf823573529e73ee2bd2204e492 | [] | no_license | devopsalok/MyDesignerClothing | f9eb064e49de27b3a5db0b636ac99c8c936fa7d4 | 0db15147ab3129970061cb430680ccfc08b57d22 | refs/heads/master | 2022-12-25T04:42:47.728518 | 2020-10-06T11:26:32 | 2020-10-06T11:26:32 | 255,033,945 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 9,284 | java | package com.mydesignerclothing.mobile.android.util;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Shader;
import android.os.Parcel;
import android.telephony.PhoneNumberUtils;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.text.method.LinkMovementMethod;
import android.text.style.CharacterStyle;
import android.text.style.ForegroundColorSpan;
import android.util.Base64;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import org.apache.commons.lang3.text.WordUtils;
import java.text.NumberFormat;
import java.util.HashMap;
import java.util.List;
import androidx.annotation.ColorInt;
import androidx.annotation.ColorRes;
import androidx.annotation.IdRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.StringRes;
import androidx.viewpager.widget.ViewPager;
import static android.view.View.VISIBLE;
/**
* STATIC Utility class for many common UI features used within this application.
*/
public class MyDSCAndroidUIUtils {
private static final String TAG = MyDSCAndroidUIUtils.class.getSimpleName();
private static final int TEXT_SIZE = 17;
private static final String[] mealNames = {"", "Baby Meal", "Bland Meal",
"Child Meal", "Toddler Meal", "Diabetic Meal",
"Gluten Free Meal", "Low Sodium/No Salt Added Meal", "Halal Meal", "Hindu Meal",
"Vegetarian Meal (Non-Dairy)", "Low Cal, Chol, Fat Meal",
"Dairy Vegetarian Meal", "Asian Vegetarian Meal", "Kosher Meal",
"Japanese Meal", "Jain Meal",
"Low Salt Meal", "Low Fat Meal", "Muslim Meal", "Vegan Vegetarian Meal", "Vegetarian/Lacto Meal"};
private static final int LENGTH_UNMASKED = 4;
private static final String MASK_CHAR = "*";
private static final String WHITESPACE = "\\s";
private static final int CHAR_AT_INDEX = 0;
private static final int SUBSTRING_INDEX = 1;
@SuppressWarnings("EmptyMethod")
private MyDSCAndroidUIUtils() {
//NOSONAR
}
private static String removeAreaCode(String formattedPhoneNumber) {
return removeSectionBeforeDash(formattedPhoneNumber);
}
private static String getAreaCode(String formattedPhoneNumber) {
String[] splits = formattedPhoneNumber.split("-");
if (splits.length == 3) {
return splits[0];
}
return null;
}
private static String removeContryCode(String formattedPhoneNumber) {
return removeSectionBeforeDash(formattedPhoneNumber);
}
private static String removeSectionBeforeDash(String formattedPhoneNumber) {
int dashIndex = formattedPhoneNumber.indexOf('-');
return formattedPhoneNumber.substring(dashIndex + 1);
}
public static boolean isCountryUS(String country) {
return "1".equals(country);
}
public static CharSequence setSpanBetweenTokens(CharSequence text, String token, CharacterStyle... cs) {
// Start and end refer to the points where the span will apply
int tokenLen = token.length();
int start = text.toString().indexOf(token) + tokenLen;
int end = text.toString().indexOf(token, start);
if (start > -1 && end > -1) {
// Copy the spannable string to a mutable spannable string
SpannableStringBuilder ssb = new SpannableStringBuilder(text);
for (CharacterStyle c : cs) {
ssb.setSpan(c, start, end, 0);
}
// Delete the tokens before and after the span
ssb.delete(end, end + tokenLen);
ssb.delete(start - tokenLen, start);
text = ssb;
}
return text;
}
private static void setTextColor(View root, @IdRes int id, @ColorRes int color) {
View view = root.findViewById(id);
if (!(view instanceof TextView)) {
return;
}
TextView textView = (TextView) view;
textView.setTextColor(root.getResources().getColor(color));
}
public static void setTextColorFor(View root, @ColorRes int color, @IdRes int... ids) {
for (int id : ids) {
setTextColor(root, id, color);
}
}
/**
* Though we don't have iOS's concept of 2x in 3x in android, as mentioned in MOB-12697,
* getFlightStatus, getFlightStatusByLeg and getFlightScheduleRequest now requires deviceType
* as 2x or 3x. This method serves the purpose.
*
* @param context
* @return
*/
public static String getScreenDensityRange(Context context) {
int densityDpi = context.getResources().getDisplayMetrics().densityDpi;
if (densityDpi >= DisplayMetrics.DENSITY_XXHIGH) {
return "3x";
}
return "2x";
}
@NonNull
public static String formatToKilos(@Nullable Integer value) {
if (value == null) {
return "";
}
int thousands = value / 1000;
NumberFormat format = NumberFormat.getInstance();
format.setGroupingUsed(true);
format.setMaximumFractionDigits(0);
return format.format(thousands) + "K";
}
public static Bitmap overlayAsteriskGradientMask(Bitmap original, Bitmap overlay) {
Bitmap bmOverlay = Bitmap.createBitmap(original.getWidth(), original.getHeight(), original.getConfig());
Canvas canvas = new Canvas(bmOverlay);
canvas.drawBitmap(original, new Matrix(), null);
canvas.drawBitmap(overlay, ((float) original.getWidth() - overlay.getWidth()) / 2, ((float) original.getHeight() - overlay.getHeight()) / 2, null);
return bmOverlay;
}
public static Bitmap overlayGradientMask(Bitmap original, Bitmap overlay, int alpha) {
Bitmap bmOverlay = Bitmap.createBitmap(original.getWidth(), original.getHeight(), original.getConfig());
Canvas canvas = new Canvas(bmOverlay);
Bitmap scaledbmp2 = scale(overlay, original.getWidth(), overlay.getHeight());
Paint paint = new Paint();
paint.setAlpha(alpha);
canvas.drawBitmap(original, new Matrix(), null);
canvas.drawBitmap(scaledbmp2, new Matrix(), paint);
return bmOverlay;
}
public static Bitmap addGradientToMask(Bitmap src, int color1, int color2) {
int w = src.getWidth();
int h = src.getHeight();
Bitmap result = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(result);
canvas.drawBitmap(src, 0, 0, null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0, 0, 0, h, color1, color2, Shader.TileMode.CLAMP);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawRect(0, 0, w, h, paint);
return result;
}
public static Bitmap scale(Bitmap bitmap, int maxWidth, int maxHeight) {
int width;
int height;
float widthRatio = (float) bitmap.getWidth() / maxWidth;
float heightRatio = (float) bitmap.getHeight() / maxHeight;
if (widthRatio >= heightRatio) {
width = maxWidth;
height = (int) (((float) width / bitmap.getWidth()) * bitmap.getHeight());
} else {
height = maxHeight;
width = (int) (((float) height / bitmap.getHeight()) * bitmap.getWidth());
}
Bitmap scaledBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
float ratioX = (float) width / bitmap.getWidth();
float ratioY = (float) height / bitmap.getHeight();
float middleX = width / 2.0f;
float middleY = height / 2.0f;
Matrix scaleMatrix = new Matrix();
scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
Canvas canvas = new Canvas(scaledBitmap);
canvas.setMatrix(scaleMatrix);
canvas.drawBitmap(bitmap, middleX - bitmap.getWidth() / 2, middleY - bitmap.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
return scaledBitmap;
}
public static boolean isActivityContextFinishing(Context context) {
Activity activity = (Activity) context;
return activity.isFinishing();
}
private static boolean isActivityFinishing(Activity activity) {
return activity.isFinishing();
}
public static int dpToPx(Context context, int dp) {
DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
return (int) ((dp * displayMetrics.density) + 0.5);
}
public static int spToPx(Context context, int sp) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp, context.getResources().getDisplayMetrics());
}
public static int convertDpToPixels(Context context, int dp) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dp * scale + 0.5f);
}
}
| [
"[email protected]"
] | |
cc55bfe8a11e52710fdf9a3e328131de56ffe537 | 35a739e572df26a47cd858b314c83e22880e6454 | /BM-core_v3/src/main/java/bm/main/engines/requests/FileEngine/UpdateFEReq.java | 4803b31ce9d39717688c52822425e50a3ab98510 | [] | no_license | MirasCarlo934/symphony | 9ccc3de48e9b1caba1554c0eddc01549dacc5b27 | 315dff76209bbd22b888eb41a6626ea6b0f4137b | refs/heads/master | 2022-12-26T03:17:09.575413 | 2020-06-20T08:21:43 | 2020-06-20T08:21:43 | 167,689,901 | 1 | 1 | null | 2022-12-12T21:41:43 | 2019-01-26T13:08:42 | Java | UTF-8 | Java | false | false | 607 | java | package bm.main.engines.requests.FileEngine;
import bm.main.engines.FileEngine;
/**
* A FileEngine request that instructs the FileEngine to read again the file it is handling.
*
* @author carlomiras
*
*/
public class UpdateFEReq extends FileEngineRequest {
/**
* Creates a FileEngine request that instructs the FileEngine to read again the file it is handling. This request is
* often sent when the file was edited outside the BM.
*
* @param id the ID of this EngineRequest
*/
public UpdateFEReq(String id, FileEngine engine) {
super(id, engine, FileEngineRequestType.update);
}
}
| [
"[email protected]"
] | |
c238b491ff7a104b67eddaa7b84c2b43db0510d2 | 3d540d03c6d693fe4a53ec601802d76a65111d38 | /app/src/main/java/com/botian/yihu/eventbus/MoniBuyEvent.java | 547ca740288326341d3245bfec97add2b229605e | [
"Apache-2.0"
] | permissive | zguming/yihu | e352482ed2df8764e1db50ad6b77edc21660fa7d | ecc4e87492a603f4171b4fbf9a53e17b90c27050 | refs/heads/master | 2021-09-21T00:59:10.192134 | 2018-08-18T08:21:06 | 2018-08-18T08:21:06 | 120,052,045 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 99 | java | package com.botian.yihu.eventbus;
public class MoniBuyEvent {
public MoniBuyEvent(){
}
}
| [
"[email protected]"
] | |
ad4ed6a75d65ba675cc574914ca4ba57120fb3d9 | a207fdb5865f7ce4f95488d266082b649a39850a | /app/src/main/java/quotes/Qutes.java | 9bd76b89414cf80a85096dce6dde8b5ed5fbb7b7 | [] | no_license | OsamaAlali/quotes | 5a29d5a5dff4c49cc8fc9499a1e4ebe621c47a3d | 97c9baa90982b0b3bdca0becc91847f17a4b2f3f | refs/heads/main | 2023-07-14T13:16:21.329633 | 2021-08-05T21:53:10 | 2021-08-05T21:53:10 | 392,650,024 | 0 | 0 | null | 2021-08-05T21:53:11 | 2021-08-04T10:43:26 | Java | UTF-8 | Java | false | false | 680 | java | package quotes;
import java.util.ArrayList;
import java.util.List;
public class Qutes {
List<String> tags;
String author;
String like;
String text;
public Qutes(List<String> tags, String author, String like, String text) {
this.tags = tags;
this.author = author;
this.like = like;
this.text = text;
}
// TODO: 8/4/2021
@Override
public String toString() {
return "Qutes{" +
"tags=" + tags +
", author='" + author + '\'' +
", like='" + like + '\'' +
", text='" + text + '\'' +
'}';
}
}
| [
"[email protected]"
] |
Subsets and Splits