content
stringlengths
0
13M
path
stringlengths
4
263
contentHash
stringlengths
1
10
package chan.spring.demo.member.dto.request import jakarta.validation.constraints.NotBlank data class WithdrawDto( @field:NotBlank(message = "๋น„๋ฐ€๋ฒˆํ˜ธ๋ฅผ ์ž…๋ ฅํ•˜์„ธ์š”.") val pw: String? )
chan-spring/src/main/kotlin/chan/spring/demo/member/dto/request/WithdrawDto.kt
2570608344
package chan.spring.demo.member.repository import com.querydsl.core.types.Projections import com.querydsl.jpa.impl.JPAQueryFactory import chan.spring.demo.exception.exception.MemberException import chan.spring.demo.exception.message.MemberExceptionMessage import chan.spring.demo.member.domain.Member import chan.spring.demo.member.domain.QMember import chan.spring.demo.member.domain.Role import chan.spring.demo.member.dto.response.MemberInfo import java.util.* class MemberCustomRepositoryImpl( private val jpaQueryFactory: JPAQueryFactory, private val member: QMember = QMember.member ) : MemberCustomRepository { override fun findMemberByEmail(email: String): Member { return jpaQueryFactory.selectFrom(member) .where(member.email.eq(email).and(member.auth.ne(Role.WITHDRAW))) .fetchOne() ?: throw MemberException(MemberExceptionMessage.MEMBER_IS_NULL, email) } override fun findMemberById(id: UUID): Member { return jpaQueryFactory.selectFrom(member) .where(member.id.eq(id).and(member.auth.ne(Role.WITHDRAW))) .fetchOne() ?: throw MemberException(MemberExceptionMessage.MEMBER_IS_NULL, id.toString()) } override fun findMemberByEmailIncludeWithdraw(email: String): Member { return jpaQueryFactory.selectFrom(member) .where(member.email.eq(email)) .fetchOne() ?: throw MemberException(MemberExceptionMessage.MEMBER_IS_NULL, email) } override fun findMemberInfoById(id: UUID): MemberInfo { return jpaQueryFactory.select( Projections.constructor( MemberInfo::class.java, member.id, member.auth, member.email ) ) .from(member) .where(member.id.eq(id).and(member.auth.ne(Role.WITHDRAW))) .fetchOne() ?: throw MemberException(MemberExceptionMessage.MEMBER_IS_NULL, id.toString()) } override fun findAuthById(id: UUID): Role { return jpaQueryFactory.select(member.auth) .from(member) .where(member.id.eq(id).and(member.auth.ne(Role.WITHDRAW))) .fetchOne() ?: throw MemberException(MemberExceptionMessage.MEMBER_IS_NULL, id.toString()) } }
chan-spring/src/main/kotlin/chan/spring/demo/member/repository/MemberCustomRepositoryImpl.kt
2579773105
package chan.spring.demo.member.repository import chan.spring.demo.member.domain.Member import org.springframework.data.jpa.repository.JpaRepository interface MemberRepository : JpaRepository<Member, Long>, MemberCustomRepository
chan-spring/src/main/kotlin/chan/spring/demo/member/repository/MemberRepository.kt
2584784151
package chan.spring.demo.member.repository import chan.spring.demo.member.domain.Member import chan.spring.demo.member.domain.Role import chan.spring.demo.member.dto.response.MemberInfo import java.util.* interface MemberCustomRepository { fun findMemberByEmail(email: String): Member fun findMemberById(id: UUID): Member fun findMemberByEmailIncludeWithdraw(email: String): Member fun findMemberInfoById(id: UUID): MemberInfo fun findAuthById(id: UUID): Role }
chan-spring/src/main/kotlin/chan/spring/demo/member/repository/MemberCustomRepository.kt
3119944128
package chan.spring.demo.member.controller.response import chan.spring.demo.member.dto.response.MemberInfo import org.springframework.http.HttpStatus import org.springframework.http.ResponseEntity object MemberResponse { private const val SIGNUP_SUCCESS = "ํšŒ์›๊ฐ€์ž…์— ์„ฑ๊ณตํ•˜์˜€์Šต๋‹ˆ๋‹ค.\n๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค." private const val LOGIN_SUCCESS = "๋กœ๊ทธ์ธ์— ์„ฑ๊ณตํ•˜์˜€์Šต๋‹ˆ๋‹ค.\nํ™˜์˜ํ•ฉ๋‹ˆ๋‹ค." private const val UPDATE_PW_SUCCESS = "๋น„๋ฐ€๋ฒˆํ˜ธ๋ฅผ ์„ฑ๊ณต์ ์œผ๋กœ ๋ณ€๊ฒฝํ•˜์˜€์Šต๋‹ˆ๋‹ค." private const val LOGOUT_SUCCESS = "๋กœ๊ทธ์•„์›ƒ์— ์„ฑ๊ณตํ•˜์˜€์Šต๋‹ˆ๋‹ค." private const val RECOVERY_SUCCESS = "๊ณ„์ • ๋ณต๊ตฌ์— ์„ฑ๊ณตํ•˜์˜€์Šต๋‹ˆ๋‹ค." private const val WITHDRAW_SUCCESS = "ํšŒ์›ํƒˆํ‡ด๋ฅผ ์„ฑ๊ณต์ ์œผ๋กœ ๋งˆ์ณค์Šต๋‹ˆ๋‹ค.\n์•ˆ๋…•ํžˆ๊ฐ€์„ธ์š”." fun infoSuccess(member: MemberInfo) = ResponseEntity.ok(member) fun signupSuccess() = ResponseEntity.status(HttpStatus.CREATED).body(SIGNUP_SUCCESS) fun loginSuccess() = ResponseEntity.ok(LOGIN_SUCCESS) fun updatePwSuccess() = ResponseEntity.ok(UPDATE_PW_SUCCESS) fun logOutSuccess() = ResponseEntity.ok(LOGOUT_SUCCESS) fun recoverySuccess() = ResponseEntity.ok(RECOVERY_SUCCESS) fun withdrawSuccess() = ResponseEntity.ok(WITHDRAW_SUCCESS) }
chan-spring/src/main/kotlin/chan/spring/demo/member/controller/response/MemberResponse.kt
3895216291
package chan.spring.demo.member.controller import chan.spring.demo.logger import chan.spring.demo.member.dto.request.* import chan.spring.demo.exception.exception.MemberException import chan.spring.demo.exception.message.MemberExceptionMessage import chan.spring.demo.jwt.dto.JwtTokenInfo import chan.spring.demo.member.controller.constant.MemberControllerConstant import chan.spring.demo.member.controller.constant.MemberRequestHeaderConstant import chan.spring.demo.member.controller.constant.MemberUrl import chan.spring.demo.member.controller.response.MemberResponse import chan.spring.demo.member.dto.response.MemberInfo import chan.spring.demo.member.log.MemberControllerLog import chan.spring.demo.member.service.command.MemberCommandService import chan.spring.demo.member.service.query.MemberQueryService import jakarta.servlet.http.HttpServletResponse import jakarta.validation.Valid import org.springframework.beans.factory.annotation.Autowired import org.springframework.http.ResponseEntity import org.springframework.web.bind.annotation.* import java.security.Principal import java.util.* @RestController class MemberController @Autowired constructor( private val memberQueryService: MemberQueryService, private val memberCommandService: MemberCommandService ) { @GetMapping(MemberUrl.INFO) fun getMemberInfo(principal: Principal): ResponseEntity<MemberInfo> { val member = memberQueryService.getMemberById(id = UUID.fromString(principal.name)) return MemberResponse.infoSuccess(member) } @PostMapping(MemberUrl.SIGNUP) fun signup( @RequestBody @Valid signupDto: SignupDto ): ResponseEntity<String> { memberCommandService.signup(signupDto) logger().info(MemberControllerLog.SIGNUP_SUCCESS + signupDto.email) return MemberResponse.signupSuccess() } @PostMapping(MemberUrl.LOGIN) fun login( @RequestBody @Valid loginDto: LoginDto, response: HttpServletResponse ): ResponseEntity<String> { val tokenInfo = memberCommandService.login(loginDto) response.apply { addHeader(MemberControllerConstant.ACCESS_TOKEN, tokenInfo.accessToken) addHeader(MemberControllerConstant.REFRESH_TOKEN, tokenInfo.refreshToken) addHeader(MemberControllerConstant.MEMBER_ID, tokenInfo.id.toString()) } logger().info(MemberControllerLog.LOGIN_SUCCESS + loginDto.email) return MemberResponse.loginSuccess() } @PutMapping(MemberUrl.JWT_TOKEN_REISSUE) fun jwtTokenReissue( @RequestHeader(MemberRequestHeaderConstant.ID) id: String?, @RequestHeader(MemberRequestHeaderConstant.REFRESH_TOKEN) refreshToken: String? ): ResponseEntity<JwtTokenInfo> { if (id.isNullOrBlank() || refreshToken.isNullOrBlank()) { throw MemberException(MemberExceptionMessage.TOKEN_REISSUE_HEADER_IS_NULL, "UNRELIABLE-MEMBER") } val memberId = UUID.fromString(id) val reissueJwtToken = memberCommandService.reissueJwtToken(memberId, refreshToken) logger().info(MemberControllerLog.JWT_TOKEN_REISSUE_SUCCESS + memberId) return ResponseEntity.ok(reissueJwtToken) } @PatchMapping(MemberUrl.UPDATE_PASSWORD) fun updatePassword( @RequestBody @Valid updatePasswordDto: UpdatePasswordDto, principal: Principal ): ResponseEntity<String> { val memberId = UUID.fromString(principal.name) memberCommandService.updatePassword(updatePasswordDto, memberId) logger().info(MemberControllerLog.UPDATE_PW_SUCCESS + memberId) return MemberResponse.updatePwSuccess() } @PostMapping(MemberUrl.LOGOUT) fun logout(principal: Principal): ResponseEntity<String> { val memberId = UUID.fromString(principal.name) memberCommandService.logout(memberId) logger().info(MemberControllerLog.LOGOUT_SUCCESS + memberId) return MemberResponse.logOutSuccess() } @PostMapping(MemberUrl.RECOVERY_MEMBER) fun recoveryMember( @RequestBody @Valid recoveryDto: RecoveryDto ): ResponseEntity<String> { memberCommandService.recoveryMember(recoveryDto) logger().info(MemberControllerLog.RECOVERY_SUCCESS + recoveryDto.email) return MemberResponse.recoverySuccess() } @DeleteMapping(MemberUrl.WITHDRAW) fun withdraw( @RequestBody @Valid withdrawDto: WithdrawDto, principal: Principal ): ResponseEntity<String> { val memberId = UUID.fromString(principal.name) memberCommandService.withdraw(withdrawDto, memberId) logger().info(MemberControllerLog.WITHDRAW_SUCCESS + memberId) return MemberResponse.withdrawSuccess() } }
chan-spring/src/main/kotlin/chan/spring/demo/member/controller/MemberController.kt
3701950676
package chan.spring.demo.member.controller.constant object MemberUrl { const val SIGNUP = "/member/signup" const val LOGIN = "/member/login" const val INFO = "/member/info" const val JWT_TOKEN_REISSUE = "/auth/reissue" const val UPDATE_PASSWORD = "/member/update/password" const val LOGOUT = "/member/logout" const val RECOVERY_MEMBER = "/member/recovery" const val WITHDRAW = "/member/withdraw" const val PROHIBITION = "/prohibition" }
chan-spring/src/main/kotlin/chan/spring/demo/member/controller/constant/MemberUrl.kt
2326422416
package chan.spring.demo.member.controller.constant object MemberControllerConstant { const val ACCESS_TOKEN = "access-token" const val REFRESH_TOKEN = "refresh-token" const val MEMBER_ID = "member-id" }
chan-spring/src/main/kotlin/chan/spring/demo/member/controller/constant/MemberControllerConstant.kt
610005557
package chan.spring.demo.member.controller.constant object MemberRequestHeaderConstant { const val ID = "id" const val REFRESH_TOKEN = "refresh-token" }
chan-spring/src/main/kotlin/chan/spring/demo/member/controller/constant/MemberRequestHeaderConstant.kt
1327604481
package chan.spring.demo.member.log object MemberServiceLog { const val SUSPEND_MEMBER = "์ •์ง€๋œ ํšŒ์›์ž…๋‹ˆ๋‹ค. ํšŒ์› Email : " const val WRONG_PW = "์ž˜๋ชป๋œ ๋น„๋ฐ€๋ฒˆํ˜ธ. ํšŒ์› ID : " }
chan-spring/src/main/kotlin/chan/spring/demo/member/log/MemberServiceLog.kt
4249911603
package chan.spring.demo.member.log object MemberControllerLog { const val SIGNUP_SUCCESS = "ํšŒ์›๊ฐ€์ž… ์„ฑ๊ณต. ํšŒ์› Email : " const val LOGIN_SUCCESS = "๋กœ๊ทธ์ธ ์„ฑ๊ณต. ํšŒ์› Email : " const val UPDATE_PW_SUCCESS = "๋น„๋ฐ€๋ฒˆํ˜ธ ๋ณ€๊ฒฝ ์„ฑ๊ณต. ํšŒ์› ID : " const val LOGOUT_SUCCESS = "ํšŒ์› ๋กœ๊ทธ์•„์›ƒ ์„ฑ๊ณต. ํšŒ์› ID : " const val RECOVERY_SUCCESS = "ํšŒ์› ๊ณ„์ • ๋ณต๊ตฌ ์„ฑ๊ณต. ํšŒ์› Email : " const val WITHDRAW_SUCCESS = "ํšŒ์›ํƒˆํ‡ด ์„ฑ๊ณต. ํšŒ์› UUID : " const val JWT_TOKEN_REISSUE_SUCCESS = "JWT ํ† ํฐ ๊ฐฑ์‹  ์„ฑ๊ณต. ํšŒ์› ID : " }
chan-spring/src/main/kotlin/chan/spring/demo/member/log/MemberControllerLog.kt
3404465270
package chan.spring.demo.member.service.command import chan.spring.demo.member.domain.Member import chan.spring.demo.member.domain.Role import chan.spring.demo.member.repository.MemberCustomRepository import org.springframework.beans.factory.annotation.Autowired import org.springframework.security.core.userdetails.User import org.springframework.security.core.userdetails.UserDetails import org.springframework.security.core.userdetails.UserDetailsService import org.springframework.stereotype.Service @Service class CustomUserDetailsService @Autowired constructor( private val memberRepository: MemberCustomRepository ) : UserDetailsService { override fun loadUserByUsername(email: String): UserDetails { val member = memberRepository.findMemberByEmail(email) return createUserDetails(member) } private fun createUserDetails(member: Member): UserDetails { return when (member.auth) { Role.ADMIN -> { createAdmin(member) } else -> { createMember(member) } } } private fun createAdmin(member: Member): UserDetails { return User.builder() .username(member.id.toString()) .password(member.password) .roles(Role.ADMIN.name) .build() } private fun createMember(member: Member): UserDetails { return User.builder() .username(member.id.toString()) .password(member.password) .roles(Role.MEMBER.name) .build() } }
chan-spring/src/main/kotlin/chan/spring/demo/member/service/command/CustomUserDetailsService.kt
1180184266
package chan.spring.demo.member.service.command import chan.spring.demo.logger import chan.spring.demo.exception.exception.MemberException import chan.spring.demo.exception.message.MemberExceptionMessage import chan.spring.demo.globalUtil.isMatchPassword import chan.spring.demo.jwt.dto.JwtTokenInfo import chan.spring.demo.jwt.filterLogic.JwtTokenProvider import chan.spring.demo.jwt.service.JwtTokenService import chan.spring.demo.member.domain.Member import chan.spring.demo.member.dto.request.* import chan.spring.demo.member.log.MemberServiceLog import chan.spring.demo.member.repository.MemberRepository import org.springframework.beans.factory.annotation.Autowired import org.springframework.security.authentication.UsernamePasswordAuthenticationToken import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder import org.springframework.security.core.Authentication import org.springframework.stereotype.Service import org.springframework.transaction.annotation.Transactional import java.util.* @Service @Transactional class MemberCommandService @Autowired constructor( private val memberRepository: MemberRepository, private val authenticationManagerBuilder: AuthenticationManagerBuilder, private val jwtTokenProvider: JwtTokenProvider, private val jwtTokenService: JwtTokenService ) { fun signup(signupDto: SignupDto) { with(signupDto) { Member.create(email!!, pw!!).also { memberRepository.save(it) } } } fun login(loginDto: LoginDto): JwtTokenInfo { val authentication: Authentication = authenticationManagerBuilder .`object` .authenticate(UsernamePasswordAuthenticationToken(loginDto.email, loginDto.pw)) return jwtTokenProvider.generateToken(authentication).also { jwtTokenService.createRefreshToken(it.id, it.refreshToken) } } fun reissueJwtToken( id: UUID, refreshToken: String ): JwtTokenInfo { val auth = memberRepository.findAuthById(id) return jwtTokenService.reissueToken(id, refreshToken, auth) } fun updatePassword( updatePasswordDto: UpdatePasswordDto, id: UUID ) { with(updatePasswordDto) { memberRepository.findMemberById(id).also { it.updatePw(newPassword!!, oldPassword!!) } } } fun logout(id: UUID) { jwtTokenService.removeRefreshToken(id) } fun recoveryMember(recoveryDto: RecoveryDto) { with(recoveryDto) { memberRepository.findMemberByEmailIncludeWithdraw(email!!).also { it.recovery(pw!!) } } } fun withdraw( withdrawDto: WithdrawDto, id: UUID ) { memberRepository.findMemberById(id) .takeIf { isMatchPassword(withdrawDto.pw!!, it.pw) } ?.also { it.withdraw() jwtTokenService.removeRefreshToken(id) } ?: run { logger().warn(MemberServiceLog.WRONG_PW + id) throw MemberException(MemberExceptionMessage.WRONG_PASSWORD, id.toString()) } } }
chan-spring/src/main/kotlin/chan/spring/demo/member/service/command/MemberCommandService.kt
736695683
package chan.spring.demo.member.service.query import chan.spring.demo.member.repository.MemberCustomRepository import org.springframework.beans.factory.annotation.Autowired import org.springframework.stereotype.Service import org.springframework.transaction.annotation.Transactional import java.util.* @Service @Transactional(readOnly = true) class MemberQueryService @Autowired constructor( private val memberRepository: MemberCustomRepository ) { fun getMemberById(id: UUID) = memberRepository.findMemberInfoById(id) }
chan-spring/src/main/kotlin/chan/spring/demo/member/service/query/MemberQueryService.kt
1842247072
package chan.spring.demo.member.domain.constant object MemberConstant { const val PW_TYPE = "VARCHAR(100)" const val ROLE_TYPE = "VARCHAR(13)" const val ADMIN_EMAIL = "[email protected]" }
chan-spring/src/main/kotlin/chan/spring/demo/member/domain/constant/MemberConstant.kt
374465378
package chan.spring.demo.member.domain import chan.spring.demo.converter.RoleConverter import chan.spring.demo.exception.exception.MemberException import chan.spring.demo.exception.message.MemberExceptionMessage import chan.spring.demo.globalUtil.UUID_TYPE import chan.spring.demo.globalUtil.createUUID import chan.spring.demo.globalUtil.encodePassword import chan.spring.demo.globalUtil.isMatchPassword import chan.spring.demo.member.domain.constant.MemberConstant import jakarta.persistence.* import org.springframework.security.core.GrantedAuthority import org.springframework.security.core.authority.SimpleGrantedAuthority import org.springframework.security.core.userdetails.UserDetails import java.util.* @Entity class Member private constructor( @Id @Column(columnDefinition = UUID_TYPE) val id: UUID = createUUID(), @Convert(converter = RoleConverter::class) @Column( nullable = false, columnDefinition = MemberConstant.ROLE_TYPE ) var auth: Role, @Column(nullable = false, unique = true) val email: String, @Column(nullable = false, columnDefinition = MemberConstant.PW_TYPE) var pw: String ) : UserDetails { companion object { private fun findFitAuth(email: String) = if (email == MemberConstant.ADMIN_EMAIL) Role.ADMIN else Role.MEMBER fun create( email: String, pw: String ): Member { return Member( auth = findFitAuth(email), email = email, pw = encodePassword(pw) ) } } fun isAdmin() = auth == Role.ADMIN fun updatePw( newPassword: String, oldPassword: String ) { require(isMatchPassword(oldPassword, pw)) { throw MemberException(MemberExceptionMessage.WRONG_PASSWORD, id.toString()) } pw = encodePassword(newPassword) } fun withdraw() { this.auth = Role.WITHDRAW } fun recovery(inputPw: String) { require( isMatchPassword(inputPw, pw) ) { throw MemberException(MemberExceptionMessage.WRONG_PASSWORD, id.toString()) } this.auth = Role.MEMBER } override fun getAuthorities(): MutableCollection<out GrantedAuthority> = arrayListOf<GrantedAuthority>(SimpleGrantedAuthority(auth.auth)) override fun getUsername() = id.toString() override fun getPassword() = pw override fun isAccountNonExpired() = true override fun isAccountNonLocked() = true override fun isCredentialsNonExpired() = true override fun isEnabled() = true }
chan-spring/src/main/kotlin/chan/spring/demo/member/domain/Member.kt
906973947
package chan.spring.demo.member.domain enum class Role(val auth: String) { MEMBER("ROLE_MEMBER"), ADMIN("ROLE_ADMIN"), WITHDRAW("ROLE_WITHDRAW") }
chan-spring/src/main/kotlin/chan/spring/demo/member/domain/Role.kt
4153554959
package chan.spring.demo.globalUtil import java.util.* const val UUID_TYPE = "BINARY(16)" fun createUUID(): UUID = UUID.randomUUID()
chan-spring/src/main/kotlin/chan/spring/demo/globalUtil/UUIDUtil.kt
3617902517
package chan.spring.demo.globalUtil import java.time.Instant import java.time.LocalDate import java.time.LocalDateTime const val DATETIME_TYPE = "BIGINT(12)" const val DATE_TYPE = "INT(8)" fun getCurrentTimestamp(): Int { return Instant.now().epochSecond.toInt() } fun getDatetimeDigit(dateTime: LocalDateTime): Long { val year = dateTime.year.toString() val month = checkSingleDigit(dateTime.monthValue) val day = checkSingleDigit(dateTime.dayOfMonth) val hour = checkSingleDigit(dateTime.hour) val minute = checkSingleDigit(dateTime.minute) return "$year$month$day$hour$minute".toLong() } fun getDateDigit(date: LocalDate): Int { val year = date.year.toString() val month = checkSingleDigit(date.monthValue) val day = checkSingleDigit(date.dayOfMonth) return "$year$month$day".toInt() } fun convertDateToLocalDate(date: Int): LocalDate { val stringDate = date.toString() val year = stringDate.substring(0, 4).toInt() val month = stringDate.substring(4, 6).toInt() val day = stringDate.substring(6).toInt() return LocalDate.of(year, month, day) } private fun checkSingleDigit(digit: Int): String { return if (digit in 0..9) { "0$digit" } else { digit.toString() } }
chan-spring/src/main/kotlin/chan/spring/demo/globalUtil/DateTimeUtil.kt
1438188613
package chan.spring.demo.globalUtil import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder fun encodePassword(password: String): String = BCryptPasswordEncoder().encode(password) fun isMatchPassword( password: String, originalEncodedPassword: String ) = BCryptPasswordEncoder().matches(password, originalEncodedPassword)
chan-spring/src/main/kotlin/chan/spring/demo/globalUtil/PasswordUtil.kt
455926569
package chan.spring.demo.globalUtil import com.querydsl.core.types.dsl.BooleanExpression import com.querydsl.core.types.dsl.EntityPathBase import com.querydsl.core.types.dsl.NumberPath fun <T, Q : EntityPathBase<T>> ltLastId( lastId: Long?, qEntity: Q, idPathExtractor: (Q) -> NumberPath<Long> ): BooleanExpression? { return lastId?.takeIf { it > 0 }?.let { idPathExtractor(qEntity).lt(it) } } fun <T, Q : EntityPathBase<T>> ltLastTimestamp( lastTimestamp: Int?, qEntity: Q, timestampPathExtractor: (Q) -> NumberPath<Int> ): BooleanExpression? { return lastTimestamp?.takeIf { it > 0 }?.let { timestampPathExtractor(qEntity).lt(it) } } fun <T> findLastIdOrDefault( foundData: List<T>, idExtractor: (T) -> Long ): Long { return foundData.lastOrNull()?.let { idExtractor(it) } ?: 0 }
chan-spring/src/main/kotlin/chan/spring/demo/globalUtil/PageQueryUtil.kt
864612930
package chan.spring.demo.exception.controllerAdvice import chan.spring.demo.exception.controllerAdvice.constant.GlobalAdviceConstant import jakarta.validation.ConstraintViolationException import org.springframework.dao.DataIntegrityViolationException import org.springframework.http.HttpStatus import org.springframework.http.ResponseEntity import org.springframework.web.bind.MethodArgumentNotValidException import org.springframework.web.bind.annotation.ExceptionHandler import org.springframework.web.bind.annotation.RestControllerAdvice import java.util.* @RestControllerAdvice class GlobalControllerAdvice { @ExceptionHandler(DataIntegrityViolationException::class) fun handleDuplicateEntityValueException(): ResponseEntity<String> { return ResponseEntity .status(HttpStatus.BAD_REQUEST) .body(GlobalAdviceConstant.DUPLICATE_ENTITY_VAL) } @ExceptionHandler(MethodArgumentNotValidException::class) fun handleValidationExceptions(exception: MethodArgumentNotValidException): ResponseEntity<String> { val bindingResult = exception.bindingResult val errorMessage = Objects .requireNonNull(bindingResult.fieldError) ?.defaultMessage return ResponseEntity.badRequest().body(errorMessage) } @ExceptionHandler(ConstraintViolationException::class) fun handleConstraintViolationException(ex: ConstraintViolationException): ResponseEntity<*> { return ResponseEntity .status(HttpStatus.BAD_REQUEST) .body(ex.message) } }
chan-spring/src/main/kotlin/chan/spring/demo/exception/controllerAdvice/GlobalControllerAdvice.kt
2822401591
package chan.spring.demo.exception.controllerAdvice import chan.spring.demo.exception.controllerAdvice.constant.MemberAdviceConstant import chan.spring.demo.exception.exception.JwtCustomException import chan.spring.demo.exception.exception.MemberException import org.springframework.http.HttpStatus import org.springframework.http.ResponseEntity import org.springframework.security.authentication.BadCredentialsException import org.springframework.web.bind.annotation.ExceptionHandler import org.springframework.web.bind.annotation.RestControllerAdvice @RestControllerAdvice class MemberControllerAdvice { @ExceptionHandler(BadCredentialsException::class) fun handleLoginFail(): ResponseEntity<String> { return ResponseEntity .status(HttpStatus.BAD_REQUEST) .body(MemberAdviceConstant.LOGIN_FAIL) } @ExceptionHandler(MemberException::class) fun handleMemberException(memberException: MemberException): ResponseEntity<String> { return ResponseEntity .status(memberException.memberExceptionMessage.status) .body(memberException.message + memberException.memberIdentifier) } @ExceptionHandler(JwtCustomException::class) fun handleJwtCustomException(jwtCustomException: JwtCustomException): ResponseEntity<String> { return ResponseEntity .status(jwtCustomException.jwtExceptionMessage.status) .body(jwtCustomException.message) } }
chan-spring/src/main/kotlin/chan/spring/demo/exception/controllerAdvice/MemberControllerAdvice.kt
2337200362
package chan.spring.demo.exception.controllerAdvice.constant object MemberAdviceConstant { const val LOGIN_FAIL = "๋กœ๊ทธ์ธ์— ์‹คํŒจํ–ˆ์Šต๋‹ˆ๋‹ค." }
chan-spring/src/main/kotlin/chan/spring/demo/exception/controllerAdvice/constant/MemberAdviceConstant.kt
3500484945
package chan.spring.demo.exception.controllerAdvice.constant object GlobalAdviceConstant { const val DUPLICATE_ENTITY_VAL = "๋ฐ์ดํ„ฐ ๋ฒ ์ด์Šค ๋ฌด๊ฒฐ์„ฑ ์กฐ๊ฑด์„ ์œ„๋ฐ˜ํ•˜์˜€์Šต๋‹ˆ๋‹ค." }
chan-spring/src/main/kotlin/chan/spring/demo/exception/controllerAdvice/constant/GlobalAdviceConstant.kt
2613627020
package chan.spring.demo.exception.message enum class JwtExceptionMessage(val status: Int, val message: String) { TOKEN_IS_NULL(404, "Token Is Null"), INVALID_TOKEN(401, "Invalid JWT Token"), EXPIRED_JWT_TOKEN(401, "Expired Jwt Token"), UNSUPPORTED_TOKEN(401, "Unsupported JWT Token"), EMPTY_CLAIMS(404, "JWT claims string is empty."), NOT_EXIST_REFRESH_TOKEN(404, "Refresh Token is not exist"), UN_MATCH_REFRESH_TOKEN(401, "Un Match Refresh Token") }
chan-spring/src/main/kotlin/chan/spring/demo/exception/message/JwtExceptionMessage.kt
3631953171
package chan.spring.demo.exception.message enum class MemberExceptionMessage(val status: Int, val message: String) { WRONG_PASSWORD(400, "๋น„๋ฐ€๋ฒˆํ˜ธ๋ฅผ ํ‹€๋ ธ์Šต๋‹ˆ๋‹ค. ํšŒ์›์‹๋ณ„์ž : "), MEMBER_IS_NULL(404, "ํšŒ์›์ด ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ํšŒ์›์‹๋ณ„์ž : "), TOKEN_REISSUE_HEADER_IS_NULL(404, "ํ† ํฐ ๊ฐฑ์‹  ํ—ค๋”๊ฐ€ ๋น„์–ด์žˆ์Šต๋‹ˆ๋‹ค.") }
chan-spring/src/main/kotlin/chan/spring/demo/exception/message/MemberExceptionMessage.kt
2826933838
package chan.spring.demo.exception.exception import chan.spring.demo.exception.message.MemberExceptionMessage class MemberException( val memberExceptionMessage: MemberExceptionMessage, val memberIdentifier: String? ) : RuntimeException(memberExceptionMessage.message)
chan-spring/src/main/kotlin/chan/spring/demo/exception/exception/MemberException.kt
508066932
package chan.spring.demo.exception.exception import chan.spring.demo.exception.message.JwtExceptionMessage class JwtCustomException(val jwtExceptionMessage: JwtExceptionMessage) : RuntimeException(jwtExceptionMessage.message)
chan-spring/src/main/kotlin/chan/spring/demo/exception/exception/JwtCustomException.kt
1319417922
package com.example.aesdecryption import androidx.test.platform.app.InstrumentationRegistry import androidx.test.ext.junit.runners.AndroidJUnit4 import org.junit.Test import org.junit.runner.RunWith import org.junit.Assert.* /** * Instrumented test, which will execute on an Android device. * * See [testing documentation](http://d.android.com/tools/testing). */ @RunWith(AndroidJUnit4::class) class ExampleInstrumentedTest { @Test fun useAppContext() { // Context of the app under test. val appContext = InstrumentationRegistry.getInstrumentation().targetContext assertEquals("com.example.aesdecryption", appContext.packageName) } }
AesDecryption/app/src/androidTest/java/com/example/aesdecryption/ExampleInstrumentedTest.kt
3254532223
package com.example.aesdecryption import org.junit.Test import org.junit.Assert.* /** * Example local unit test, which will execute on the development machine (host). * * See [testing documentation](http://d.android.com/tools/testing). */ class ExampleUnitTest { @Test fun addition_isCorrect() { assertEquals(4, 2 + 2) } }
AesDecryption/app/src/test/java/com/example/aesdecryption/ExampleUnitTest.kt
401737945
package com.example.aesdecryption fun Char.fromHexToInt() : Int { return if(this in '0' .. '9') this.code - '0'.code else this.code - 'a'.code + 10 }
AesDecryption/app/src/main/java/com/example/aesdecryption/Extension.kt
4088452463
package com.example.aesdecryption import androidx.appcompat.app.AppCompatActivity import android.os.Bundle import android.util.Log import android.widget.Toast import com.example.aesdecryption.databinding.ActivityMainBinding import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.async import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.io.BufferedReader import java.io.InputStreamReader import java.net.ServerSocket import java.net.Socket class MainActivity : AppCompatActivity() { private lateinit var binding : ActivityMainBinding private val aes = CBC() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) binding = ActivityMainBinding.inflate(layoutInflater) setContentView(binding.root) binding.apply { decryptButton.setOnClickListener { if(inputEditText.text?.isNotEmpty() == true){ CoroutineScope(Dispatchers.Main).launch{ val res = async(Dispatchers.Default){ aes.decrypt(inputEditText.text.toString()) }.await() output.setText(res) } } else{ Toast.makeText(this@MainActivity,"Fill in all information",Toast.LENGTH_SHORT).show() } } } val socket = ServerSocket(50000) try{ CoroutineScope(Dispatchers.IO).launch { while(true){ val client = socket.accept() val reader = BufferedReader(InputStreamReader(client.getInputStream())) val secretKey = reader.readLine() val iv = reader.readLine() val cipher = reader.readLine() withContext(Dispatchers.Main){ binding.inputEditText.setText(cipher) } aes.setIV(iv) aes.setSecretKey(secretKey) } } }catch(ex : Exception) { ex.printStackTrace() } } }
AesDecryption/app/src/main/java/com/example/aesdecryption/MainActivity.kt
2666287106
package com.example.aesdecryption val iSBox = arrayOf( arrayOf( 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb ), arrayOf( 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb ), arrayOf( 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e ), arrayOf( 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 ), arrayOf( 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 ), arrayOf( 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 ), arrayOf( 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 ), arrayOf( 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b ), arrayOf( 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 ), arrayOf( 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e ), arrayOf( 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b ), arrayOf( 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 ), arrayOf( 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f ), arrayOf( 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef ), arrayOf( 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 ), arrayOf( 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6,0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d ) ) val invMixCol = arrayOf( arrayOf(0x0e, 0x0b, 0x0d, 0x09), arrayOf(0x09, 0x0e, 0x0b, 0x0d), arrayOf(0x0d, 0x09, 0x0e, 0x0b), arrayOf(0x0b, 0x0d, 0x09, 0x0e) ) val sBox = arrayOf( arrayOf(0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76), arrayOf(0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0), arrayOf(0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15), arrayOf(0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75), arrayOf(0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84), arrayOf(0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF), arrayOf(0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8), arrayOf(0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2), arrayOf(0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73), arrayOf(0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB), arrayOf(0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79), arrayOf(0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08), arrayOf(0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A), arrayOf(0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E), arrayOf(0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF), arrayOf(0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16) ) val roundConstant = arrayOf(0,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d,0x9a)
AesDecryption/app/src/main/java/com/example/aesdecryption/Constant.kt
225282360
package com.example.aesdecryption import android.util.Log class CBC { private lateinit var _secretKey : String private lateinit var iv : Array<Array<Int>> private var word = Array(4){Array(4){0} } private var numOfRound : Int = 0 private val numOfRoundKeyMap = mapOf(16 to 44,24 to 52,32 to 60) fun setIV(temp : String) { iv = Array(4){Array(4){0} } for(i in 0 until 4){ for(j in 0 until 4){ iv[i][j] = temp[4*i+j].fromHexToInt() } } } private fun rotWord(word : Array<Int>) : Array<Int>{ val temp = word[0] for(i in 0 until 3){ word[i] = word[i+1] } word[3] = temp return word } fun subWord(word : Array<Int>) : Array<Int>{ for(i in 0 until 4){ word[i] = subByte(word[i]) } return word } fun subByte(byte : Int ) : Int{ return throughSBox(byte) } private fun throughSBox(value : Int) : Int{ var hex = Integer.toHexString(value) hex = padByte(hex) val first = hex[0].fromHexToInt() val second = hex[1].fromHexToInt() return sBox[first][second] } fun copyWord(a : Array<Int>,b : Array<Int>) { for(i in 0 until 4){ a[i] = b[i] } } fun rCon(word : Array<Int>,round : Int) : Array<Int>{ word[0] = word[0] xor roundConstant[round] return word } fun keyExpansion(){ val keyLength = _secretKey.length/2 for(i in 0 until keyLength/4){ for(j in 0 until 4){ word[i][j] = "${_secretKey[2*(4*i+j)]}${_secretKey[2*(4*i+j)+1]}".toInt(16) } } for(i in keyLength/4 until numOfRoundKeyMap[keyLength]!!){ for(j in 0 until 4){ var temp = Array(4){0} copyWord(temp,word[i-1]) if(i%(keyLength/4) == 0){ temp = rCon(subWord(rotWord(temp)),i/(keyLength/4)) } word[i] = xorWord(temp,word[i-(keyLength/4)]) } } for(j in 0 until 44){ val i = 0 Log.i("word[$] ","${word[j][i] } ${word[j][i+1] } ${word[j][i+2] } ${word[j][i+3] }") } } fun setSecretKey(key : String){ _secretKey = key when(_secretKey.length){ 32 -> { numOfRound = 10 word = Array(44){Array(4){0} } } 48 -> { numOfRound = 12 word = Array(52){Array(4){0} } } 64 -> { numOfRound = 14 word = Array(60){Array(4){0} } } } keyExpansion() } private fun hexToState(hex : String,blocks : Int) : Array<Array<Array<Int>>>{ val state = Array(blocks){Array(4){Array(4){0} } } for(i in 0 until blocks){ for(j in 0 until 4){ for(k in 0 until 4){ state[i][j][k] = "${hex[i*32+j*8+2*k]}${hex[i*32+j*8+2*k+1]}".toInt(16) } } } return state } private fun copy(a1 : Array<Array<Int>>,a2 : Array<Array<Int>>){ for(i in 0 until 4){ for(j in 0 until 4){ a2[i][j] = a1[i][j] } } } fun addRoundKey(state : Array<Array<Int>>,round : Int){ for(i in 0 until 4){ state[i] = xorWord(state[i], word[4*round + i]) } } fun invSubState(state: Array<Array<Int>>){ for(i in 0 until 4){ for(j in 0 until 4){ state[i][j] = invSubByte(state[i][j]) } } } fun intArrayToPlainText(state : Array<Array<Array<Int>>>,blocks : Int) : String{ var res = "" for(k in 0 until blocks){ if(k == blocks - 1){ if(state[k][3][3] <= 15){ var temp = state[k][3][3] var isPadded = true var i = 3 var j = 3 while(temp > 0){ if(state[k][i][j] != state[k][3][3]){ isPadded = false break } j-- if(j == -1){ i-- j = 3 } temp-- } if(isPadded){ if(0 == state[k+1][0][0]){ i = 0 j = 0 temp = 0 while(temp < 16 - state[k][3][3]){ res += state[k][i][j].toChar() j++ if(j == 4){ i++ j = 0 } temp++ } return res } } } } for(i in 0 until 4){ for(j in 0 until 4){ res += state[k][i][j].toChar() } } } return res } private fun throughISBox(value : Int) : Int{ var hex = Integer.toHexString(value) hex = padByte(hex) val first = hex[0].fromHexToInt() val second = hex[1].fromHexToInt() return iSBox[first][second] } fun invSubByte(byte : Int) : Int{ return throughISBox(byte) } fun padByte(str : String) : String{ var res = str if(str.length == 1){ res = "0${str}" } return res } fun byteMultiplication(byte1 : Int,byte2 : Int) : Int{ if(byte2 == 0x01) return byte1 var res = 0 var a = byte1 var b = byte2 for(i in 0 until 8){ if(b and 0x01 == 0x01){ res = a xor res } var temp = 0 if(a and 0x80 == 0x80){ temp = 0x1b } a = (a shl 1)%256 xor temp b = b shr 1 } return res } fun invMixColumn(state : Array<Array<Int>>) : Array<Array<Int>>{ val temp = Array(4){Array(4){0} } for(i in 0 until 4){ for(j in 0 until 4){ for(k in 0 until 4){ temp[j][i] = temp[j][i] xor byteMultiplication(invMixCol[i][k],state[j][k]) } } } return temp } fun xorWord(word1 : Array<Int>,word2 : Array<Int>) : Array<Int>{ for(i in 0 until 4){ word1[i] = word1[i] xor word2[i] } return word1 } fun xor4Words(state : Array<Array<Int>>,iV : Array<Array<Int>>){ for(i in 0 until 4){ state[i] = xorWord(state[i], iV[i]) } } fun invShiftRow(state : Array<Array<Int>>){ for(i in 1 until 4){ for(k in 0 until i){ val temp = state[3][i] for (j in 3 downTo 1){ state[j][i] = state[j-1][i] } state[0][i] = temp } } } fun decrypt(cipherText : String) : String{ var iVTemp = iv val blocks = cipherText.length/16/2 val state = hexToState(cipherText,blocks) for(n in 0 until blocks-1){ // Store Cn-1 val temp = Array(4){Array(4){0}} copy(state[n],temp) // Pn = Cn-1 xor D(Kn,Cn) addRoundKey(state[n],numOfRound) for(i in numOfRound-1 downTo 1){ invShiftRow(state[n]) invSubState(state[n]) addRoundKey(state[n],i) state[n] = invMixColumn(state[n]) } invShiftRow(state[n]) invSubState(state[n]) addRoundKey(state[n],0) xor4Words(state[n],iVTemp) iVTemp = temp } return intArrayToPlainText(state,blocks-1) } }
AesDecryption/app/src/main/java/com/example/aesdecryption/CBC.kt
3322770181
package ru.dmitriyt.graphtreeanalyser import org.junit.jupiter.api.Test import ru.dmitriyt.graphtreeanalyser.data.GraphCache import ru.dmitriyt.graphtreeanalyser.data.TreeUtil import ru.dmitriyt.graphtreeanalyser.data.algorithm.ReducedTreePack2Type import ru.dmitriyt.graphtreeanalyser.data.algorithm.ReducedTreePackEquals1 import kotlin.test.assertEquals class ReducedTreePack2TypeSubGraphs { // [:H`ESgp`^, :H`EKWTjB, :H`EKWT`B, :H`EKIOlB, :H`EKIO`B] @Test fun test() { val graph6 = ":H`ESgp`^" val type = ReducedTreePack2Type.solve(GraphCache[graph6]) assertEquals(1, type) } }
graph-tree-analyser/src/test/kotlin/ru/dmitriyt/graphtreeanalyser/ReducedTreePack2TypeSubGraphs.kt
2285201469
package ru.dmitriyt.graphtreeanalyser class Args( val n: Int, val isMulti: Boolean = DEFAULT_IS_MULTI, val partSize: Int = DEFAULT_PART_SIZE, val useCache: Boolean = false, ) { companion object { const val DEFAULT_IS_MULTI = false const val DEFAULT_PART_SIZE = 64 } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/Args.kt
2960125869
package ru.dmitriyt.graphtreeanalyser import kotlinx.coroutines.runBlocking import ru.dmitriyt.graphtreeanalyser.data.algorithm.ReducedTreePack2Type import ru.dmitriyt.graphtreeanalyser.data.algorithm.ReducedTreePackEquals2 import ru.dmitriyt.graphtreeanalyser.presentation.graphs fun main(rawArgs: Array<String>): Unit = runBlocking { // repeat(20) { // val args = ArgsManager(rawArgs).parse() val args = Args( n = 12, isMulti = 12 > 10, ) graphs(n = args.n) { multiThreadingEnabled = args.isMulti generate(generator = "gentreeg") .filter(ReducedTreePackEquals2) .apply { calculateInvariant(ReducedTreePack2Type) } } // } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/Main.kt
113726303
package ru.dmitriyt.graphtreeanalyser.data sealed class AbstractGraphCode { data class SingleComponent(val code: List<Int>) : AbstractGraphCode() data class MultiComponent(val codes: List<List<Int>>) : AbstractGraphCode() }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/AbstractGraphCode.kt
3592977748
package ru.dmitriyt.graphtreeanalyser.data.repository import com.google.gson.GsonBuilder import com.google.gson.reflect.TypeToken import ru.dmitriyt.graphtreeanalyser.domain.SolveResult import ru.dmitriyt.graphtreeanalyser.domain.model.GraphResult import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo import java.io.File object SolveRepository { private val solveStorage = File("results").apply { if (!exists()) { mkdir() } } private val gson = GsonBuilder().setPrettyPrinting().create() fun get(graphTaskInfo: GraphTaskInfo, n: Int): SolveResult? { val file = getSolveFile(graphTaskInfo, n) if (!file.exists()) return null return runCatching { when (graphTaskInfo) { is GraphTaskInfo.Condition -> { val typeToken = object : TypeToken<List<String>>() {}.type SolveResult.Condition( graphs = gson.fromJson(file.readLines().joinToString("\n"), typeToken), ) } is GraphTaskInfo.Invariant -> { val typeToken = object : TypeToken<Map<String, Int>>() {}.type SolveResult.Invariant( invariants = gson.fromJson<Map<String, Int>>(file.readLines().joinToString("\n"), typeToken) .map { GraphResult(it.key, it.value) }, ) } } } .onFailure { it.printStackTrace() } .getOrNull() } fun set(graphTaskInfo: GraphTaskInfo, n: Int, solveResult: SolveResult) { val file = getSolveFile(graphTaskInfo, n) file.createNewFile() when (solveResult) { is SolveResult.Condition -> { file.writeText(gson.toJson(solveResult.graphs)) } is SolveResult.Invariant -> { file.writeText(gson.toJson(solveResult.invariants.map { it.graph6 to it.invariant }.toMap())) } } } private fun getSolveFile(graphTaskInfo: GraphTaskInfo, n: Int): File { val graphTaskName = when (graphTaskInfo) { is GraphTaskInfo.Invariant -> graphTaskInfo.task.toString() is GraphTaskInfo.Condition -> graphTaskInfo.task.toString() } return File(solveStorage, "${graphTaskName}_$n.json") } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/repository/SolveRepository.kt
2148973004
package ru.dmitriyt.graphtreeanalyser.data fun Graph.getAbstractCode(): AbstractGraphCode { val components = getComponents() fun getTreeCode(tree: Graph): List<Int> { val center = TreeUtil.getTreeCenter(tree) return TreeUtil.getCanonicalCode(tree, center) } return if (components.size == 1) { AbstractGraphCode.SingleComponent(getTreeCode(components.first())) } else { AbstractGraphCode.MultiComponent(components.map { getTreeCode(it) }.sortedBy { it.toCodeString() }) } } fun Graph.getComponents(): List<Graph> { val components = mutableListOf<List<Int>>() val vertexes = mapList.keys val visited = mutableMapOf<Int, Boolean>() vertexes.forEach { visited[it] = false } while (!visited.all { it.value }) { val componentVertexes = TreeUtil.dfsWithoutEdge(this, vertexes.first { visited[it] == false }, -1) componentVertexes.forEach { visited[it] = true } components.add(componentVertexes) } return components.map { componentVertexes -> Graph( mapList.filter { componentVertexes.contains(it.key) }.map { entry -> entry.key to entry.value.filter { componentVertexes.contains(it) } }.toMap() ) } } object TreeUtil { fun bfs(g: Graph, source: Int): List<Int> { val d = MutableList(g.n) { Int.MAX_VALUE } d[source] = 0 val q = ArrayDeque<Int>() q.addLast(source) while (q.isNotEmpty()) { val u = q.removeLast() g.mapList[u].orEmpty().forEach { v -> if (d[v] == Int.MAX_VALUE) { d[v] = d[u] + 1 q.addLast(v) } } } return d } fun getTreeCenterVertexes(g: Graph): Set<Int> { val actualVertexes = g.mapList.keys.toMutableSet() while (actualVertexes.size > 2) { val vertexesToRemove = mutableListOf<Int>() g.mapList.forEach { (vertex, vertexes) -> if (actualVertexes.contains(vertex)) { if (vertexes.count { actualVertexes.contains(it) } == 1) { vertexesToRemove.add(vertex) } } } vertexesToRemove.forEach { vertex -> actualVertexes.remove(vertex) } } return actualVertexes } fun getTreeCenter(g: Graph): Int { val actualVertexes = getTreeCenterVertexes(g) if (actualVertexes.size == 1) { return actualVertexes.first() } val center1 = actualVertexes.first() val center2 = actualVertexes.last() val graph1Vertexes = dfsWithoutEdge(g, center1, center2) val graph2Vertexes = dfsWithoutEdge(g, center2, center1) if (graph1Vertexes.size < graph2Vertexes.size) { return center1 } if (graph2Vertexes.size < graph1Vertexes.size) { return center2 } val graph1 = g.filterVertexes { graph1Vertexes.contains(it) } val graph2 = g.filterVertexes { graph2Vertexes.contains(it) } return if (getCanonicalCode(graph1, center1).toCodeString() >= getCanonicalCode( graph2, center2 ).toCodeString() ) { center1 } else { center2 } } fun dfsWithoutEdge(g: Graph, start: Int, skip: Int): List<Int> { val visited = mutableMapOf<Int, Boolean>() fun dfs(u: Int) { visited[u] = true g.mapList[u]?.forEach { vertex -> if (vertex != skip && visited[vertex] != true) { dfs(vertex) } } } dfs(start) return visited.filter { it.value }.keys.toList() } fun getCanonicalCode(g: Graph, center: Int): List<Int> = try { val codes = g.mapList.map { entry -> entry.key to mutableListOf<Int>() }.toMap().toMutableMap() val leaves = g.getLeaves() leaves.forEach { vertex -> codes[vertex]?.add(1) } val levels = dijkstra(g, center) val used = mutableListOf<Int>() g.mapList.keys.forEach { i -> if (codes[i]?.isEmpty() == true && i != center) { used.add(i) codeHelper(g, center, codes, i, null, used, levels) } } var count = 1 repeat(g.mapList[center]!!.size) { i -> count += codes[g.mapList[center]!![i]]?.get(0) ?: 0 } codes[center]?.add(count) val h = mutableListOf<List<Int>>() repeat(g.mapList[center]!!.size) { i -> h.add(codes[g.mapList[center]?.get(i)]!!) } h.sortBy { it.toCodeString() } h.forEach { hi -> hi.forEach { hij -> codes[center]?.add(hij) } } val code = mutableListOf<Int>() codes[center]?.forEach { code.add(it) } code } catch (e: Exception) { throw e } private fun codeHelper( g: Graph, center: Int, codes: MutableMap<Int, MutableList<Int>>, start: Int, parent: Int?, used: MutableList<Int>, levels: Map<Int, Int> ) { g.mapList[start]?.forEach { v -> if (v != center && codes[v]?.size == 0 && v != parent && !used.contains(v) && levels[v]!! >= levels[start]!!) { codeHelper(g, center, codes, v, parent, used, levels) } } var count = 1 g.mapList[start]?.forEach { v -> if (v != parent && v != center && levels[v]!! >= levels[start]!!) { count += codes[v]?.get(0)!! } } codes[start]?.add(count) val h = mutableListOf<List<Int>>() g.mapList[start]?.forEach { v -> if (v != parent && v != center && levels[v]!! >= levels[start]!!) { h.add(codes[v].orEmpty()) } } h.sortBy { it.toCodeString() } h.forEach { hi -> hi.forEach { hij -> codes[start]?.add(hij) } } } private fun dijkstra(g: Graph, center: Int): Map<Int, Int> { val used = mutableSetOf<Int>() val d = g.mapList.map { entry -> entry.key to Int.MAX_VALUE }.toMap().toMutableMap() d[center] = 0 repeat(g.mapList.size) { var v: Int? = null g.mapList.keys.forEach { j -> if (!used.contains(j) && (v == null || d[j]!! < d[v]!!)) { v = j } } if (v == null) { return d } used.add(v!!) g.mapList[v]?.forEach { j -> if (d[v]!! + 1 < d[j]!!) { d[j] = d[v]!! + 1 } } } return d } } fun List<Int>.toCodeString(): String { return map { 'a' + it }.joinToString("") } fun Graph.getLeaves(): List<Int> { val leaves = mutableListOf<Int>() mapList.forEach { (vertex, vertexes) -> if (vertexes.size == 1) { leaves.add(vertex) } } return leaves }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/TreeUtil.kt
1448146436
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant open class AbstractCondition(private val graphInvariant: GraphInvariant, private val invariantValue: Int) : GraphCondition { override fun check(graph: Graph): Boolean { return graphInvariant.solve(graph) == invariantValue } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/AbstractCondition.kt
3834714781
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.getLeaves import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object LeavesCount : GraphInvariant { override fun solve(graph: Graph): Int { return graph.getLeaves().size } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/LeavesCount.kt
2444742619
package ru.dmitriyt.graphtreeanalyser.data.algorithm data object TreeCenterSizeEquals1 : AbstractCondition(graphInvariant = TreeCenterSize, invariantValue = 1)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeCenterSizeEquals1.kt
3048121768
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.TreeUtil.bfs import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object TreeRadius : GraphInvariant { override fun solve(graph: Graph): Int { val e = graph.mapList.keys.map { bfs(graph, it).max() } return e.min() } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeRadius.kt
517861763
package ru.dmitriyt.graphtreeanalyser.data.algorithm data object ReducedTreePackEquals2 : AbstractCondition(graphInvariant = ReducedTreePack, invariantValue = 2)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/ReducedTreePackEquals2.kt
145180486
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.presentation.and data object TreeIsStarBicentral : GraphCondition by (ReducedTreePackEquals1 and TreeCenterSizeEquals2)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeIsStarBicentral.kt
3811171220
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.TreeUtil import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object TreeCenterSize : GraphInvariant { override fun solve(graph: Graph): Int { return TreeUtil.getTreeCenterVertexes(graph).size } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeCenterSize.kt
1307197563
package ru.dmitriyt.graphtreeanalyser.data.algorithm data object ReducedTreePackEquals1 : AbstractCondition(graphInvariant = ReducedTreePack, invariantValue = 1)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/ReducedTreePackEquals1.kt
4229454435
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.TreeUtil.bfs import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object TreeDiameter : GraphInvariant { override fun solve(graph: Graph): Int { val u = bfs(graph, 0).withIndex().maxBy { it.value }.index return bfs(graph, u).max() } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeDiameter.kt
1386781881
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.AbstractGraphCode import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.getAbstractCode import ru.dmitriyt.graphtreeanalyser.data.getLeaves import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object ReducedTreePack : GraphInvariant { override fun solve(graph: Graph): Int { val treePack = mutableListOf<AbstractGraphCode>() val leaves = graph.getLeaves() leaves.forEach { vertex -> val newGraph = graph.filterVertexes { it != vertex } treePack.add(newGraph.getAbstractCode()) } return treePack.toSet().size } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/ReducedTreePack.kt
35483751
package ru.dmitriyt.graphtreeanalyser.data.algorithm data object TreeCenterSizeEquals2 : AbstractCondition(graphInvariant = TreeCenterSize, invariantValue = 2)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeCenterSizeEquals2.kt
1814221767
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.presentation.and data object TreeIsStarCentral : GraphCondition by (ReducedTreePackEquals1 and TreeCenterSizeEquals1)
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/TreeIsStarCentral.kt
3923409644
package ru.dmitriyt.graphtreeanalyser.data.algorithm import ru.dmitriyt.graphtreeanalyser.data.AbstractGraphCode import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.TreeUtil import ru.dmitriyt.graphtreeanalyser.data.getAbstractCode import ru.dmitriyt.graphtreeanalyser.data.getLeaves import ru.dmitriyt.graphtreeanalyser.domain.Logger import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant data object ReducedTreePack2Type : GraphInvariant { override fun solve(graph: Graph): Int { val type = getGraphType(graph) println("GRAPH_TYPE = $type") return type } private fun getGraphType(graph: Graph): Int { val graphs = getScSbSubGraphs(graph) ?: run { // ะฟะพะปัƒั‡ะธะปะธ ะฑะพะปัŒัˆะต ะดะฒัƒั… ะบะพะผะฟะพะฝะตะฝั‚ SC/SB Logger.e("ะฟะพะปัƒั‡ะธะปะธ ะฑะพะปัŒัˆะต ะดะฒัƒั… ะบะพะผะฟะพะฝะตะฝั‚ SC/SB") return 0 } if (graphs.size == 2) { // ะฝะฐัˆะปะธ ะดะฒะฐ ะบะฐะบะธั… ั‚ะพ ะฟะพะดะณั€ะฐั„ะฐ SC ะธะปะธ SB val graph1 = graphs[0] val graph2 = graphs[1] if (TreeIsStarCentral.check(graph1) && TreeIsStarCentral.check(graph2)) { // ะดะฒะฐ SC ะณั€ะฐั„ะฐ // ะฟั€ะพะฒะตั€ะธะผ ั‡ั‚ะพ ะฟะตั€ะตัะตะบะฐัŽั‚ัั ะพะฝะธ ั‚ะพะปัŒะบะพ ะฟะพ ั†ะตะฟะธ val commonVertexes = graph1.mapList.keys.toSet().intersect(graph2.mapList.keys.toSet()) if (commonVertexes.size == 1) { // ัั‚ะพ ะฟัƒั‚ัŒ ะฝัƒะปะตะฒะพะน ะดะปะธะฝั‹ - ั‚ะพั‡ะบะฐ ะฟะตั€ะตัะตั‡ะตะฝะธั ะดะฒัƒั… SC Logger.i("ัั‚ะพ ะฟัƒั‚ัŒ ะฝัƒะปะตะฒะพะน ะดะปะธะฝั‹ - ั‚ะพั‡ะบะฐ ะฟะตั€ะตัะตั‡ะตะฝะธั ะดะฒัƒั… SC") return 1 } else if (commonVertexes.isNotEmpty()) { // SC1 ะธ SC2 ั ะพะฑั‰ะตะน ั‡ะฐัั‚ัŒัŽ ะฑะพะปัŒัˆะต ั‡ะตะผ 1 ะฒะตั€ัˆะธะฝะฐ, ะธ ัั‚ะพ ะฟะพ ะธะดะตะต ั‚ะธะฟ 3, // ะฟะพั‚ะพะผ ะฝะฐะดะพ ะฑัƒะดะตั‚ ะดะพั€ะฐะฑะพั‚ะฐั‚ัŒ ะฟั€ะพะฒะตั€ะบะธ ะธัะบะปัŽั‡ะตะฝะธั ะดั€ัƒะณะธั… ะณั€ะฐั„ะพะฒ, ะตัะปะธ ะฑัƒะดัƒั‚ Logger.i("SC1 ะธ SC2 ั ะพะฑั‰ะตะน ั‡ะฐัั‚ัŒัŽ ะฑะพะปัŒัˆะต ั‡ะตะผ 1 ะฒะตั€ัˆะธะฝะฐ") return 3 } else { // ะดะฒะฐ SC ัะพะตะดะธะฝะตะฝั‹ ั‡ะตั€ะตะท ั†ะตะฟัŒ (ั†ะตะฟัŒ ะฒ ะฝะธั… ะฝะต ะฒั…ะพะดะธั‚ ะฟะพ ัั‚ะพะน ะฟั€ะพะณะต) val overVertexes = graph.mapList.keys - graph1.mapList.keys - graph2.mapList.keys if (isPath(graph, overVertexes) && isPathConnectedToCenterOfSCB(graph, graph1, overVertexes) && isPathConnectedToCenterOfSCB(graph, graph2, overVertexes) ) { Logger.i("ะดะฒะฐ SC ัะพะตะดะธะฝะตะฝั‹ ั‡ะตั€ะตะท ั†ะตะฟัŒ") return 1 } else { val center1 = TreeUtil.getTreeCenterVertexes(graph1).first() val center2 = TreeUtil.getTreeCenterVertexes(graph2).first() if (graph.mapList[center1].orEmpty().contains(center2)) { // ะดะฒะฐ SC ัะพะตะดะธะฝะตะฝั‹ ะฟั€ะพัั‚ะพ ะดั€ัƒะณ ั ะดั€ัƒะณะพะผ ะทะฐ ะฒะตั€ัˆะธะฝั‹ ั‡ะตั€ะตะท ะฝัƒะปะตะฒัƒัŽ ั†ะตะฟัŒ Logger.i("ะดะฒะฐ SC ัะพะตะดะธะฝะตะฝั‹ ะฟั€ะพัั‚ะพ ะดั€ัƒะณ ั ะดั€ัƒะณะพะผ ะทะฐ ะฒะตั€ัˆะธะฝั‹ ั‡ะตั€ะตะท ะฝัƒะปะตะฒัƒัŽ ั†ะตะฟัŒ") return 1 } else { Logger.e("ะฝะฐัˆะปะธ ะดะฒะฐ SC, ะฝะพ ะพะฝะธ ะฝะต ัะพะตะดะธะฝะตะฝั‹ ั‡ะตั€ะตะท ั†ะตะฟัŒ (ะฒะพะทะผะพะถะฝะพ ะฝัƒะปะตะฒัƒัŽ)") // ะฝะฐัˆะปะธ ะดะฒะฐ SC, ะฝะพ ะพะฝะธ ะฝะต ัะพะตะดะธะฝะตะฝั‹ ั‡ะตั€ะตะท ั†ะตะฟัŒ (ะฒะพะทะผะพะถะฝะพ ะฝัƒะปะตะฒัƒัŽ) } } } } else if (TreeIsStarBicentral.check(graph1) && TreeIsStarBicentral.check(graph2)) { // ะดะฒะฐ BC ะณั€ะฐั„ะฐ val center1 = TreeUtil.getTreeCenterVertexes(graph1) val center2 = TreeUtil.getTreeCenterVertexes(graph2) if (center1 == center2) { // ะฐ ั‚ัƒั‚ ะตัั‚ัŒ ะฒะฐั€ะธะฐะฝั‚ั‹, ะผั‹ ะฝะฐัˆะปะธ SB ะธ SB ั ะพะดะธะฝะฐะบะพะฒั‹ะผ ั†ะตะฝั‚ั€ะพะผ, ะฝะพ ะฒะดั€ัƒะณ ัƒ ะฝะธั… ะตั‰ะต ะตัั‚ัŒ ะดั€ัƒะณะฐั ะพะฑั‰ะฐั ั‡ะฐัั‚ัŒ val commonVertexes = graph1.mapList.keys.toSet().intersect(graph2.mapList.keys.toSet()) if (commonVertexes.size > 2) { // ะฟะพ ะธะดะตะต ั‚ัƒั‚ ะพะฑั‰ะฐั ั‡ะฐัั‚ัŒ ะฑะพะปัŒัˆะต ั‡ะตะผ ะดะฒะต ะฒะตั€ัˆะธะฝั‹ ั†ะตะฝั‚ั€ะฐะปัŒะฝั‹ั…, ะฝะพ ะฑะพะปัŒัˆะต ะฝะธั‡ะตะณะพ ะฝะต ะฟั€ะพะฒะตั€ัะป ะฟะพ ั‚ะธะฟัƒ 4 return 4 } else { return 2 } } else { Logger.e("ะฝะตะฟะพะฝัั‚ะฝะฐั ะฟะพะบะฐ ั‡ั‚ะพ ัˆั‚ัƒะบะฐ - SB ะธ SB, ะบะพั‚ะพั€ั‹ะต ะธะผะตัŽั‚ ั€ะฐะทะฝั‹ะน ั†ะตะฝั‚ั€, ะฟะพ ะธะดะตะต, ั‚ะฐะบะพะณะพ ะฝะต ะผะพะถะตั‚ ะฑั‹ั‚ัŒ") // ะฝะตะฟะพะฝัั‚ะฝะฐั ะฟะพะบะฐ ั‡ั‚ะพ ัˆั‚ัƒะบะฐ - SB ะธ SB, ะบะพั‚ะพั€ั‹ะต ะธะผะตัŽั‚ ั€ะฐะทะฝั‹ะน ั†ะตะฝั‚ั€, ะฟะพ ะธะดะตะต, ั‚ะฐะบะพะณะพ ะฝะต ะผะพะถะตั‚ ะฑั‹ั‚ัŒ } } else { // ั‚ัƒั‚ ะฝะตะฟั€ะฐะฒะธะปัŒะฝะพ ัั‡ะธั‚ะฐะตะผ ะณั€ะฐั„ั‹, ะฝะฐ ะฟั€ะธะผะตั€ะต n9/18 Logger.e("ัะพะฒะตั€ัˆะตะฝะฝะพ ะฝะตะฟะพะฝัั‚ะฝะฐั ัˆั‚ัƒะบะฐ, ะฟะพ ะธะดะตะต ั‚ะฐะบะพะน ะฝะต ะดะพะปะถะฝะพ ะฑั‹ั‚ัŒ (SC ะธ SB)") Logger.e("${getGraphStarType(graph1)} : ${graph1.mapList.keys} and ${getGraphStarType(graph2)} ${graph2.mapList.keys}") // ัะพะฒะตั€ัˆะตะฝะฝะพ ะฝะตะฟะพะฝัั‚ะฝะฐั ัˆั‚ัƒะบะฐ, ะฟะพ ะธะดะตะต ั‚ะฐะบะพะน ะฝะต ะดะพะปะถะฝะพ ะฑั‹ั‚ัŒ (SC ะธ SB) } } else if (graphs.size == 1) { // ะผะพะถะตั‚ ะฑั‹ั‚ัŒ ัะปัƒั‡ะฐะน, ะบะพะณะดะฐ ะบ ั†ะตะฟะธ ะบั€ะตะฟะธั‚ัั SC ะทะฐ ัะตั€ะตะดะธะฝัƒ, ั‚.ะต. ั†ะตะฟัŒ ัั‚ะพ ะฒั‹ั€ะพะถะดะตะฝะฝั‹ะน ัะปัƒั‡ะฐะน ะฒั‚ะพั€ะพะณะพ SC (ั‚ะฐะบ ะบะฐะบ ั‚ะพะปัŒะบะพ ะพะดะธะฝ ะปะธัั‚) val graph1 = graphs[0] val overVertexes = graph.mapList.keys - graph1.mapList.keys if (TreeIsStarCentral.check(graph1) && isPath(graph, overVertexes) && isPathConnectedToCenterOfSCB(graph, graph1, overVertexes) ) { Logger.i("ะบ ั†ะตะฟะธ ะบั€ะตะฟะธั‚ัั SC ะทะฐ ัะตั€ะตะดะธะฝัƒ") return 1 } else { Logger.e("ะฝะฐัˆะปะธ 1 ะณั€ะฐั„ SC/SB, ะฝะพ ัั‚ะพ ะฝะต SC/SB + P") // ะฝะฐัˆะปะธ 1 ะณั€ะฐั„, ะฝะพ ัั‚ะพ ะฝะต SC + P } } else { Logger.e("ะฝะฐัˆะปะธ > 2 ะณั€ะฐั„ะพะฒ, ะฒะพะพะฑั‰ะต ะฝะตะฟะพะฝัั‚ะฝะพ ั‡ั‚ะพ ั‚ะฐะบะพะต") // ะฝะฐัˆะปะธ > 2 ะณั€ะฐั„ะพะฒ, ะฒะพะพะฑั‰ะต ะฝะตะฟะพะฝัั‚ะฝะพ ั‡ั‚ะพ ั‚ะฐะบะพะต } return 0 } /** * ะŸะพะปัƒั‡ะตะฝะธะต ะณั€ะฐั„ะพะฒ SC/SB, ะบะพั‚ะพั€ั‹ะต ะธะผะตัŽั‚ัั ะฒ ะณั€ะฐั„ะต [graph] ั ะฟั€ะธะฒะตะดะตะฝะฝะพะน ะบะพะปะพะดะพะน 2 (ะฟะพ ะฟะพะดะพะฑะฝั‹ะผ ะปะธัั‚ัŒัะผะธ) * ะ˜ะดะตะผ ะธ ะพั‚ัะตะบะฐะตะผ ะปะธัั‚ัŒั ะดั€ัƒะณะพะณะพ ะฟะพะดะพะฑะธั, ะฟะพะบะฐ ะฝะต ะฟะพะปัƒั‡ะธะผ SC/SB */ fun getScSbSubGraphs(graph: Graph): List<Graph>? { val leaveToSubgraphCode = mutableListOf<Pair<Int, AbstractGraphCode>>() graph.getLeaves().forEach { vertex -> val newGraph = graph.filterVertexes { it != vertex } leaveToSubgraphCode.add(vertex to newGraph.getAbstractCode()) } val sameLeavesGroups = leaveToSubgraphCode.groupBy { it.second }.map { (_, value) -> value.map { it.first } } Logger.i("sameLeavesGroups:") if (sameLeavesGroups.size > 2) { // ะฟะพะปัƒั‡ะธะปะธ ะฑะพะปัŒัˆะต 2ั… ะฟะพะดะพะฑะฝั‹ั… ะปะธัั‚ัŒะตะฒ, ะทะฝะฐั‡ะธั‚ ัั‚ะพ ะฝะต ะณั€ะฐั„ ั ะบะพะปะธั‡ะตัั‚ะฒะพะผ ะฟั€ะธะฒะตะดะตะฝะฝะพะน ะบะพะปะพะดั‹ 2 return null } val graphs = sameLeavesGroups.mapNotNull { leavesGroup -> Logger.i("sameLeavesGroup $leavesGroup") // leavesGroup - ะฒะตั€ัˆะธะฝั‹, ะฟั€ะธ ัƒะดะฐะปะตะฝะธะธ ะบะพั‚ะพั€ั‹ั… ะฟะพะปัƒั‡ะฐัŽั‚ัั ะฟะพะดะพะฑะฝั‹ะต ะณั€ะฐั„ั‹ // ั‚.ะต. ะฑัƒะดะตะผ ัƒะฑะธั€ะฐั‚ัŒ ะฒัะต ะพัั‚ะฐะปัŒะฝั‹ะต ะปะธัั‚ัŒั, ะฟะพะบะฐ ะฝะต ะฟะพะปัƒั‡ะธะผ ะดะตั€ะตะฒะพ ั ะบะพะปะธั‡ะตัั‚ะฒะพะผ ะฟั€ะธะฒะตะดะตะฝะฝะพะน ะบะพะปะพะดั‹ 1 var currentGraph = graph.copy() var otherLeaves = currentGraph.getLeaves().toSet() - leavesGroup.toSet() var forceStop = false while ( !(ReducedTreePackEquals1.check(currentGraph) && // ะธั‰ะตะผ ะณั€ะฐั„ SC ะธะปะธ SB currentGraph.getLeaves().toSet() == leavesGroup.toSet()) && // ั‡ั‚ะพะฑั‹ ะปะธัั‚ัŒั ะฑั‹ะปะธ ั‚ะพะปัŒะบะพ ั‚ะต, ั‡ั‚ะพ ะฒ ะณั€ัƒะฟะฟะต otherLeaves.isNotEmpty() && // ะฟะพะบะฐ ะตัั‚ัŒ ั‡ั‚ะพ ะพั‚ะบัƒัั‹ะฒะฐั‚ัŒ !forceStop ) { val oldGraph = currentGraph currentGraph = currentGraph.filterVertexes { !otherLeaves.contains(it) } forceStop = oldGraph == currentGraph // ะพัั‚ะฐะฝะพะฒะธะผัั, ะตัะปะธ ะณั€ะฐั„ ะฝะต ะฟะพะผะตะฝัะปัั otherLeaves = currentGraph.getLeaves().toSet() - leavesGroup.toSet() } // ะฝะฐัˆะปะธ ะณั€ะฐั„ SC ะธะปะธ SB, (ะตัะปะธ ะฝะตั‚, ั‚ะพ ะฟะพั‚ะพะผ ั€ะฐะทะฑะตั€ะตะผัั ั ัั‚ะธะผ ะบะตะนัะพะผ currentGraph.takeIf { ReducedTreePackEquals1.check(currentGraph) } } return graphs } fun getPathStartEnd(g: Graph, path: Set<Int>): Pair<Int, Int> { if (path.isEmpty()) { error("path is empty") } if (path.size == 1) return path.first() to path.first() val (start, end) = path.filter { vertex -> path.count { g.mapList[vertex]?.contains(it) == true } == 1 } return start to end } fun isPath(g: Graph, path: Set<Int>): Boolean { if (path.isEmpty()) return false if (path.size == 1) return true val mutablePath = path.toMutableSet() val startVertex = path.find { vertex -> path.count { g.mapList[vertex]?.contains(it) == true } == 1 } var currentVertex = startVertex mutablePath.remove(currentVertex) while (currentVertex != null) { currentVertex = g.mapList[currentVertex].orEmpty().find { mutablePath.contains(it) } mutablePath.remove(currentVertex) } return mutablePath.isEmpty() } private fun isPathConnectedToCenterOfSCB(g: Graph, scb: Graph, path: Set<Int>): Boolean { val graph1Center = TreeUtil.getTreeCenterVertexes(scb).first() return getPathStartEnd(g, path).let { (pathStart, pathEnd) -> g.mapList[graph1Center].orEmpty().let { it.contains(pathStart) || it.contains(pathEnd) } } } private fun getGraphStarType(graph: Graph): String { if (TreeIsStarCentral.check(graph)) { return "SC" } else if (TreeIsStarBicentral.check(graph)) { return "SB" } else { return "ER" } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/algorithm/ReducedTreePack2Type.kt
129165146
package ru.dmitriyt.graphtreeanalyser.data internal class ByteReader6(s6: String) { private val mBytes: ByteArray private val mSize: Int private var mPos: Int private var mBit = 0 init { mBytes = s6.toByteArray() mSize = s6.length mPos = mBit } // ! whether k bits are available fun haveBits(k: Int): Boolean { return mPos + (mBit + k - 1) / 6 < mSize } // ! return the next integer encoded in graph6 fun getNumber(): Int { assert(mPos < mSize) var c = mBytes[mPos] assert(c >= 63) c = (c - 63).toByte() ++mPos if (c < 126) return c.toInt() assert(false) return 0 } // ! return the next bit encoded in graph6 fun getBit(): Int { assert(mPos < mSize) var c = mBytes[mPos] assert(c >= 63) c = (c - 63).toByte() c = (c.toInt() shr 5 - mBit).toByte() mBit++ if (mBit == 6) { mPos++ mBit = 0 } return c.toInt() and 0x01 } // ! return the next bits as an integer fun getBits(k: Int): Int { var v = 0 for (i in 0 until k) { v *= 2 v += getBit() } return v } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/ByteReader6.kt
2182366193
package ru.dmitriyt.graphtreeanalyser.data import java.util.concurrent.ConcurrentHashMap object GraphCache { private val cache = ConcurrentHashMap<String, Graph>() operator fun get(graph6: String): Graph { return cache[graph6] ?: run { val graph = Graph.fromSparse6(graph6) cache[graph6] = graph graph } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/GraphCache.kt
345405774
package ru.dmitriyt.graphtreeanalyser.data import kotlin.math.ceil import kotlin.math.ln data class Graph( val mapList: Map<Int, List<Int>>, ) { val n: Int = mapList.size companion object { fun fromSparse6(codeSparse6: String): Graph { val code = codeSparse6.substring(1) val byteReader = ByteReader6(code) val n = byteReader.getNumber() val k = ceil(ln(n.toDouble()) / ln(2.0)).toInt() val map = mutableMapOf<Int, MutableList<Int>>() repeat(n) { map[it] = mutableListOf() } var v = 0 while (byteReader.haveBits(k + 1)) { val b = byteReader.getBit() val x = byteReader.getBits(k) if (b != 0) { v++ } if (v >= n) { break } if (x > v) { v = x } else { map[x]?.add(v) map[v]?.add(x) } } return Graph(map) } } fun filterVertexes(isAdd: (vertex: Int) -> Boolean): Graph { return Graph( mapList.filter { isAdd(it.key) }.map { entry -> entry.key to entry.value.filter { isAdd(it) } }.toMap() ) } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/data/Graph.kt
3938547056
package ru.dmitriyt.graphtreeanalyser.domain import ru.dmitriyt.graphtreeanalyser.domain.model.GraphResult sealed interface SolveResult { data class Condition( val graphs: List<String>, ) : SolveResult data class Invariant( val invariants: List<GraphResult>, ) : SolveResult }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/SolveResult.kt
431668384
package ru.dmitriyt.graphtreeanalyser.domain.solver import ru.dmitriyt.graphtreeanalyser.domain.model.Task import ru.dmitriyt.graphtreeanalyser.domain.model.TaskResult interface TaskSolver { fun run( inputProvider: () -> Task, resultHandler: (TaskResult) -> Unit, onFinish: () -> Unit, ) }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/solver/TaskSolver.kt
3943302748
package ru.dmitriyt.graphtreeanalyser.domain.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.GraphCache import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo interface GraphCondition { fun check(graph6: String): Boolean = check(GraphCache[graph6]) fun check(graph: Graph): Boolean } fun GraphCondition.toGraphTaskInfo(): GraphTaskInfo { return GraphTaskInfo.Condition(this) }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/algorithm/GraphCondition.kt
3623991615
package ru.dmitriyt.graphtreeanalyser.domain.algorithm import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.data.GraphCache import ru.dmitriyt.graphtreeanalyser.domain.Logger import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo interface GraphInvariant { fun solve(graph6: String): Int { Logger.i("\n") Logger.i(graph6) return solve(GraphCache[graph6]) } fun solve(graph: Graph): Int } fun GraphInvariant.toGraphTaskInfo(): GraphTaskInfo { return GraphTaskInfo.Invariant(this) }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/algorithm/GraphInvariant.kt
254600425
package ru.dmitriyt.graphtreeanalyser.domain.model sealed class TaskResult( open val taskId: Int, open val processedGraphs: Int, ) { data class Invariant( override val taskId: Int, override val processedGraphs: Int, val results: List<GraphResult>, ) : TaskResult(taskId, processedGraphs) data class Graphs( override val taskId: Int, override val processedGraphs: Int, val graphs: List<String>, ) : TaskResult(taskId, processedGraphs) }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/model/TaskResult.kt
835593607
package ru.dmitriyt.graphtreeanalyser.domain.model data class GraphResult( val graph6: String, val invariant: Int, )
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/model/GraphResult.kt
2996593651
package ru.dmitriyt.graphtreeanalyser.domain.model import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant sealed class GraphTaskInfo { data class Invariant( val task: GraphInvariant, ) : GraphTaskInfo() data class Condition( val task: GraphCondition, ) : GraphTaskInfo() }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/model/GraphTaskInfo.kt
1251459235
package ru.dmitriyt.graphtreeanalyser.domain.model data class Task( val id: Int, val graphs: List<String>, ) { companion object { val EMPTY = Task(-1, emptyList()) } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/model/Task.kt
1074579764
package ru.dmitriyt.graphtreeanalyser.domain private const val IS_DEBUG = true private const val ANSI_RESET = "\u001B[0m" private const val ANSI_RED = "\u001B[31m" object Logger { fun d(any: Any) { if (IS_DEBUG) { println(any) } } fun e(any: Any) { println(ANSI_RED + any + ANSI_RESET) } fun i(any: Any) { println(any) } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/domain/Logger.kt
4151012569
package ru.dmitriyt.graphtreeanalyser.presentation import ru.dmitriyt.graphtreeanalyser.data.GraphCache import java.awt.BasicStroke import java.awt.Color import java.awt.Font import java.awt.Graphics import java.awt.Graphics2D import java.awt.Rectangle import java.awt.image.BufferedImage import java.io.File import javax.imageio.ImageIO import kotlin.math.cos import kotlin.math.sin /** * ะšะปะฐัั ะดะปั ัะพะทะดะฐะฝะธั ะธะทะพะฑั€ะฐะถะตะฝะธั ะณั€ะฐั„ะฐ */ class GraphDrawer( /** ะŸัƒั‚ัŒ ัะพั…ั€ะฐะฝะตะฝะธั ะธะทะพะฑั€ะฐะถะตะฝะธะน */ private val path: String = PATH, /** ะŸะพะดะฟะธัั‹ะฒะฐั‚ัŒ ะปะธ ะณั€ะฐั„ */ private val hasTitle: Boolean = true, /** ะ ะฐะทะผะตั€ ะธะทะพะฑั€ะฐะถะตะฝะธั */ private val imageSize: Int = IMAGE_SIZE, /** ะ ะฐะดะธัƒั ะฒะตั€ัˆะธะฝั‹ */ private val vertexRadius: Int = VERTEX_RADIUS, /** ะ ะฐะดะธัƒั ะณั€ะฐั„ะฐ */ private val graphRadius: Int = GRAPH_RADIUS, ) { companion object { const val IMAGE_SIZE = 300 const val VERTEX_RADIUS = 20 const val GRAPH_RADIUS = 100 const val PATH = "graphs/" private const val EXTENSION = "png" } /** * ะกะพะทะดะฐั‚ัŒ ะธ ัะพั…ั€ะฐะฝะธั‚ัŒ ะธะทะพะฑั€ะฐะถะตะฝะธะต ะณั€ะฐั„ะฐ * @param graph6 - ะณั€ะฐั„ ะฒ ั„ะพั€ะผะฐั‚ะต graph6 */ fun drawImage(graph6: String) { val graph = GraphCache[graph6] val n = graph.n val image = BufferedImage(imageSize, imageSize, BufferedImage.TYPE_INT_ARGB) val graphics = image.createGraphics() graphics.apply { paint = Color.WHITE fillRect(0, 0, imageSize, imageSize) paint = Color.BLACK val vertexCount = graph.n val dAngle = 360 / vertexCount var angle = 0 if (hasTitle) { font = Font(null, Font.BOLD, 14) drawString(graph6, 0, 16) } // ั€ะธัะพะฒะฐะฝะธะต ั€ะตะฑะตั€ repeat(graph.n) { i -> repeat(graph.n) { j -> if (graph.mapList[i].orEmpty().contains(j)) { val (x1, y1) = getVertexCenter(i, dAngle) val (x2, y2) = getVertexCenter(j, dAngle) drawEdge(this, x1, y1, x2, y2) } } } // ั€ะธัะพะฒะฐะฝะธะต ะฒะตั€ัˆะธะฝ font = Font(null, Font.BOLD, 24) repeat(graph.n) { vertex -> drawVertex( this, vertex, imageSize / 2 + (graphRadius * sin(Math.toRadians(angle.toDouble()))).toInt(), imageSize / 2 + (graphRadius * cos(Math.toRadians(angle.toDouble()))).toInt() ) angle += dAngle } dispose() } val dir = File(path) if (!dir.exists()) { dir.mkdir() } val dirByN = File(dir, "n$n") if (!dirByN.exists()) { dirByN.mkdir() } val number = dirByN.listFiles()?.size ImageIO.write(image, EXTENSION, File(dirByN, "$number.$EXTENSION")) } private fun getVertexCenter(vertex: Int, dAngle: Int): Pair<Int, Int> { val angle = dAngle * vertex val x = imageSize / 2 + (graphRadius * sin(Math.toRadians(angle.toDouble()))).toInt() val y = imageSize / 2 + (graphRadius * cos(Math.toRadians(angle.toDouble()))).toInt() return x to y } private fun drawVertex(graphics: Graphics2D, vertex: Int, centerX: Int, centerY: Int) { graphics.stroke = BasicStroke(2f) graphics.paint = Color.LIGHT_GRAY graphics.fillOval( centerX - vertexRadius, centerY - vertexRadius, 2 * vertexRadius, 2 * vertexRadius ) graphics.paint = Color.BLACK graphics.drawOval( centerX - vertexRadius, centerY - vertexRadius, 2 * vertexRadius, 2 * vertexRadius ) graphics.drawCenteredString( vertex.toString(), Rectangle( centerX - vertexRadius, centerY - vertexRadius, 2 * vertexRadius, 2 * vertexRadius ) ) } private fun drawEdge(graphics: Graphics2D, v1x: Int, v1y: Int, v2x: Int, v2y: Int) { graphics.paint = Color.BLACK graphics.stroke = BasicStroke(4f) graphics.drawLine(v1x, v1y, v2x, v2y) } private fun Graphics.drawCenteredString(text: String, rect: Rectangle) { val metrics = getFontMetrics(font) val x = rect.x + (rect.width - metrics.stringWidth(text)) / 2 val y = rect.y + (rect.height - metrics.height) / 2 + metrics.ascent drawString(text, x, y) } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/GraphDrawer.kt
1959658484
package ru.dmitriyt.graphtreeanalyser.presentation.input import ru.dmitriyt.graphtreeanalyser.presentation.BlockingSolverInput val input9 = BlockingSolverInput.DataInputProvider( graphs = """ :H`ESxol^ :H`ESxOl^ :H`ESwol^ :H`ESwTl^ :H`EShQ`^ :H`EShP`^ :H`EShOl^ :H`EShOlZ :H`EShOlB :H`ESgt`^ :H`ESgp`^ :H`ESgol^ :H`ESgolZ :H`ESgolB :H`ESgTlZ :H`ESgTlV :H`ESgTlB :H`ESgT`^ :H`ESgT`B :H`ESYP`^ :H`ESYOl^ :H`ESYOlB :H`ESWp`^ :H`ESWol^ :H`ESWolB :H`ESWTlV :H`ESWTlB :H`ESIT`^ :H`ESIT`B :H`EKWpbB :H`EKWp`^ :H`EKWp`B :H`EKWolZ :H`EKWolB :H`EKWo`B :H`EKWTjV :H`EKWTjB :H`EKWT`^ :H`EKWT`B :H`EKIS`^ :H`EKIS`B :H`EKIOlB :H`EKIO`B :H`ECwT`^ :H`ECwT`B :H`ECwO`B :H`ACGO`B """.trimIndent().split("\n") )
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/input/input9.kt
2084416584
package ru.dmitriyt.graphtreeanalyser.presentation.input import ru.dmitriyt.graphtreeanalyser.presentation.BlockingSolverInput val input7 = BlockingSolverInput.DataInputProvider( graphs = """ :FaYiL :FaYeL :FaYbL :FaXeW :FaXeL :FaXeG :FaXbK :FaXbG :FaWmL :FaWmG :FaGaG """.trimIndent().split("\n") )
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/input/input7.kt
1573932378
package ru.dmitriyt.graphtreeanalyser.presentation import ru.dmitriyt.graphtreeanalyser.domain.Logger import ru.dmitriyt.graphtreeanalyser.domain.SolveResult import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant import ru.dmitriyt.graphtreeanalyser.domain.algorithm.toGraphTaskInfo suspend fun graphs(n: Int, block: suspend SolveScope.() -> Unit) { SolveScope(n).block() } class SolverQueryScope class SolveScope( private val n: Int, ) { var multiThreadingEnabled = false fun generate(generator: String): BlockingSolverInput { return BlockingSolverInput.GengProvider(generator = generator, n = n) } suspend fun run(queryProvider: SolverQueryScope.() -> GraphInvariantSelectionWithDataAndFilters) { val query = SolverQueryScope().queryProvider() query.inputProvider().filter(query.filter).apply { query.selection.invariants.forEach { calculateInvariant(it) } } } suspend fun BlockingSolverInput.filter( graphCondition: GraphCondition, partSize: Int = 1024, ): BlockingSolverInput { val conditionSolver = BlockingSolver( isMulti = multiThreadingEnabled, n = n, input = this, graphTaskInfo = graphCondition.toGraphTaskInfo(), partSize = partSize, ) val conditionResult = conditionSolver.solve() as SolveResult.Condition Logger.i("----- N = $n $graphCondition : ${conditionResult.graphs.size} -----") return BlockingSolverInput.DataInputProvider(conditionResult.graphs) } fun BlockingSolverInput.saveImages(path: String = GraphDrawer.PATH) { val graphDrawer = GraphDrawer(path = path) read(Int.MAX_VALUE).forEach { graphDrawer.drawImage(it) } } suspend fun BlockingSolverInput.calculateInvariant( graphInvariant: GraphInvariant, partSize: Int = 256 ): SolveResult.Invariant { val invariantSolver = BlockingSolver( isMulti = multiThreadingEnabled, n = n, input = this, graphTaskInfo = graphInvariant.toGraphTaskInfo(), partSize = partSize, ) val invariantResult = invariantSolver.solve() as SolveResult.Invariant if (invariantResult.invariants.isNotEmpty()) { Logger.i("----- $graphInvariant value : count -----") val minInvariant = invariantResult.invariants.minOfOrNull { it.invariant }!! val maxInvariant = invariantResult.invariants.maxOfOrNull { it.invariant }!! for (i in minInvariant..maxInvariant) { Logger.i("$graphInvariant $i\t:\t${invariantResult.invariants.count { it.invariant == i }}") } } return invariantResult } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/SolverScope.kt
1254198620
package ru.dmitriyt.graphtreeanalyser.presentation.solver import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo import ru.dmitriyt.graphtreeanalyser.domain.model.Task import ru.dmitriyt.graphtreeanalyser.domain.model.TaskResult import ru.dmitriyt.graphtreeanalyser.domain.solver.TaskSolver import kotlin.concurrent.thread /** * ะœะฝะพะณะพะฟะพั‚ะพั‡ะฝั‹ะน ะฒั‹ั‡ะธัะปะธั‚ะตะปัŒ */ class MultiThreadSolver(private val graphTaskInfo: GraphTaskInfo) : TaskSolver { override fun run(inputProvider: () -> Task, resultHandler: (TaskResult) -> Unit, onFinish: () -> Unit) { val nCpu = Runtime.getRuntime().availableProcessors() val threads = IntRange(0, nCpu).map { thread { SingleSolver(graphTaskInfo).run(inputProvider, resultHandler, onFinish) } } threads.map { it.join() } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/solver/MultiThreadSolver.kt
4268355926
package ru.dmitriyt.graphtreeanalyser.presentation.solver import ru.dmitriyt.graphtreeanalyser.domain.model.GraphResult import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo import ru.dmitriyt.graphtreeanalyser.domain.model.Task import ru.dmitriyt.graphtreeanalyser.domain.model.TaskResult import ru.dmitriyt.graphtreeanalyser.domain.solver.TaskSolver /** * ะžะดะฝะพะฟะพั‚ะพั‡ะฝั‹ะน ะฒั‹ั‡ะธัะปะธั‚ะตะปัŒ */ class SingleSolver(private val graphTaskInfo: GraphTaskInfo) : TaskSolver { override fun run(inputProvider: () -> Task, resultHandler: (TaskResult) -> Unit, onFinish: () -> Unit) { var task = inputProvider() var graphs = getGraphsFromTask(task) while (task != Task.EMPTY) { resultHandler( when (graphTaskInfo) { is GraphTaskInfo.Invariant -> TaskResult.Invariant( task.id, graphs.size, graphs.map { GraphResult(it, graphTaskInfo.task.solve(it)) }, ) is GraphTaskInfo.Condition -> TaskResult.Graphs( task.id, graphs.size, graphs.filter { graphTaskInfo.task.check(it) }, ) } ) task = inputProvider() graphs = getGraphsFromTask(task) } onFinish() } private fun getGraphsFromTask(task: Task): List<String> { val list = task.graphs return list } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/solver/SingleSolver.kt
158934687
package ru.dmitriyt.graphtreeanalyser.presentation import ru.dmitriyt.graphtreeanalyser.domain.Logger import java.io.BufferedReader import java.io.File import java.io.InputStreamReader import kotlin.math.min sealed interface BlockingSolverInput { fun read(partSize: Int): List<String> class GengProvider(generator: String, n: Int) : BlockingSolverInput { private val commandList = listOfNotNull( "./$generator", n.toString(), ).apply { Logger.d("generate command: ${this.joinToString(" ")}") } private val process = ProcessBuilder(*commandList.toTypedArray()) .directory(File(System.getProperty("user.dir"))).start() private val reader = BufferedReader( InputStreamReader( process.inputStream ) ) override fun read(partSize: Int): List<String> { val graphs = mutableListOf<String>() repeat(partSize) { val mayBeGraph = synchronized(this) { reader.readLine() } mayBeGraph?.takeIf { !it.startsWith(">") }?.takeIf { it.isNotEmpty() }?.let { graphs.add(it) } ?: run { return@repeat } } return graphs } } class DataInputProvider( private val graphs: List<String>, ) : BlockingSolverInput { private var currentOffset: Int = 0 @Synchronized override fun read(partSize: Int): List<String> { if (currentOffset >= graphs.size) return emptyList() val taskGraphs = graphs.subList(currentOffset, min(currentOffset + partSize, graphs.size)) currentOffset += partSize return taskGraphs } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/BlockingSolverInput.kt
4219119318
package ru.dmitriyt.graphtreeanalyser.presentation import ru.dmitriyt.graphtreeanalyser.data.Graph import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphCondition import ru.dmitriyt.graphtreeanalyser.domain.algorithm.GraphInvariant fun SolverQueryScope.selectGraphCounts(vararg graphInvariant: GraphInvariant): GraphInvariantSelection { return GraphInvariantSelection(graphInvariant.toList()) } data class GraphInvariantSelection( val invariants: List<GraphInvariant>, ) data class GraphInvariantSelectionWithData( val selection: GraphInvariantSelection, val inputProvider: () -> BlockingSolverInput, ) data class GraphInvariantSelectionWithDataAndFilters( val selection: GraphInvariantSelection, val inputProvider: () -> BlockingSolverInput, val filter: GraphCondition, ) fun generator(generator: String, n: Int): () -> BlockingSolverInput { return { BlockingSolverInput.GengProvider(generator, n) } } infix fun GraphInvariantSelection.from(inputProvider: () -> BlockingSolverInput): GraphInvariantSelectionWithData { return GraphInvariantSelectionWithData(this, inputProvider) } infix fun GraphInvariantSelectionWithData.where(graphCondition: GraphCondition): GraphInvariantSelectionWithDataAndFilters { return GraphInvariantSelectionWithDataAndFilters( selection = selection, inputProvider = inputProvider, filter = graphCondition, ) } infix fun GraphInvariantSelectionWithDataAndFilters.or( graphCondition: GraphCondition ): GraphInvariantSelectionWithDataAndFilters { return copy( filter = filter or graphCondition, ) } infix fun GraphInvariantSelectionWithDataAndFilters.and( graphCondition: GraphCondition ): GraphInvariantSelectionWithDataAndFilters { return copy( filter = filter and graphCondition, ) } infix fun GraphCondition.or(graphCondition: GraphCondition) = ComplexOrCondition(this, graphCondition) infix fun GraphCondition.and(graphCondition: GraphCondition) = ComplexAndCondition(this, graphCondition) data class ComplexAndCondition( val graphConditions: List<GraphCondition> ) : GraphCondition { constructor(vararg condition: GraphCondition) : this(condition.toList()) override fun check(graph: Graph): Boolean { return graphConditions.all { it.check(graph) } } } data class ComplexOrCondition( val graphConditions: List<GraphCondition> ) : GraphCondition { constructor(vararg condition: GraphCondition) : this(condition.toList()) override fun check(graph: Graph): Boolean { return graphConditions.any { it.check(graph) } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/GraphQuery.kt
2978057160
package ru.dmitriyt.graphtreeanalyser.presentation import ru.dmitriyt.graphtreeanalyser.data.repository.SolveRepository import ru.dmitriyt.graphtreeanalyser.domain.Logger import ru.dmitriyt.graphtreeanalyser.domain.SolveResult import ru.dmitriyt.graphtreeanalyser.domain.model.GraphTaskInfo import ru.dmitriyt.graphtreeanalyser.domain.model.Task import ru.dmitriyt.graphtreeanalyser.domain.model.TaskResult import ru.dmitriyt.graphtreeanalyser.presentation.solver.MultiThreadSolver import ru.dmitriyt.graphtreeanalyser.presentation.solver.SingleSolver import java.util.concurrent.atomic.AtomicBoolean import java.util.concurrent.atomic.AtomicInteger import kotlin.coroutines.resume import kotlin.coroutines.suspendCoroutine import kotlin.time.Duration.Companion.milliseconds class BlockingSolver( private val isMulti: Boolean, private val n: Int, private val input: BlockingSolverInput, private val graphTaskInfo: GraphTaskInfo, private val partSize: Int, ) { private val taskId = AtomicInteger(0) private val total = AtomicInteger(0) private var isStartFinishing = AtomicBoolean(false) private val processedGraphs = AtomicInteger(0) private val lock = Object() private val taskResults = mutableListOf<TaskResult>() private var startTime = 0L private var endTime = 0L suspend fun solve(): SolveResult = suspendCoroutine { val cachedResult: SolveResult? = null //SolveRepository.get(graphTaskInfo, n) if (cachedResult != null) { it.resume(cachedResult) return@suspendCoroutine } val solver = if (isMulti) { MultiThreadSolver(graphTaskInfo) } else { SingleSolver(graphTaskInfo) } startTime = System.currentTimeMillis() solver.run( inputProvider = { val graphs = input.read(partSize) if (graphs.isNotEmpty()) { val newTaskId = taskId.incrementAndGet() total.getAndAdd(graphs.size) Task( id = newTaskId, graphs = graphs, ) } else { Task.EMPTY } }, resultHandler = { taskResult -> processedGraphs.getAndAdd(taskResult.processedGraphs) synchronized(lock) { taskResults.add(taskResult) } }, onFinish = { if (total.get() == processedGraphs.get() && !isStartFinishing.getAndSet(true)) { endTime = System.currentTimeMillis() Logger.d( """ ---------- Task $graphTaskInfo Processed graphs: ${total.get()} Time passed: ${(endTime - startTime).milliseconds} ---------- """.trimIndent() ) val result = when (graphTaskInfo) { is GraphTaskInfo.Condition -> { SolveResult.Condition( graphs = taskResults.filterIsInstance<TaskResult.Graphs>().flatMap { it.graphs }, ) } is GraphTaskInfo.Invariant -> { SolveResult.Invariant( invariants = taskResults.filterIsInstance<TaskResult.Invariant>().flatMap { it.results }, ) } } SolveRepository.set(graphTaskInfo, n, result) it.resume(result) } } ) } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/presentation/BlockingSolver.kt
572509012
package ru.dmitriyt.graphtreeanalyser class ArgsManager(rawArgs: Array<String>) { private val rawArgsList = rawArgs.toList() fun parse(): Args { return Args( n = n, isMulti = isMulti, partSize = partSize, ) } private val isMulti: Boolean get() = rawArgsList.contains("-m") private val partSize: Int get() = getParam("-p")?.toIntOrNull() ?: Args.DEFAULT_PART_SIZE private val n: Int get() = getParam("-n")?.toIntOrNull() ?: error("-n param is required") private fun getParam(key: String): String? { return rawArgsList.indexOf(key).takeIf { it > -1 }?.let { rawArgsList.getOrNull(it + 1) } } }
graph-tree-analyser/src/main/kotlin/ru/dmitriyt/graphtreeanalyser/ArgsManager.kt
2186299603
package com.example.myapplication import androidx.test.platform.app.InstrumentationRegistry import androidx.test.ext.junit.runners.AndroidJUnit4 import org.junit.Test import org.junit.runner.RunWith import org.junit.Assert.* /** * Instrumented test, which will execute on an Android device. * * See [testing documentation](http://d.android.com/tools/testing). */ @RunWith(AndroidJUnit4::class) class ExampleInstrumentedTest { @Test fun useAppContext() { // Context of the app under test. val appContext = InstrumentationRegistry.getInstrumentation().targetContext assertEquals("com.example.myapplication", appContext.packageName) } }
top-vpn/app/src/androidTest/java/com/example/myapplication/ExampleInstrumentedTest.kt
1188990709
package com.example.myapplication import org.junit.Test import org.junit.Assert.* /** * Example local unit test, which will execute on the development machine (host). * * See [testing documentation](http://d.android.com/tools/testing). */ class ExampleUnitTest { @Test fun addition_isCorrect() { assertEquals(4, 2 + 2) } }
top-vpn/app/src/test/java/com/example/myapplication/ExampleUnitTest.kt
2019423820
package com.example.myapplication import androidx.appcompat.app.AppCompatActivity import android.os.Bundle class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) } }
top-vpn/app/src/main/java/com/example/myapplication/MainActivity.kt
665038924
package com.example.myapplication import android.content.Intent import android.os.Build import android.os.Bundle import android.view.Window import androidx.activity.enableEdgeToEdge import androidx.appcompat.app.AppCompatActivity import androidx.core.view.ViewCompat import androidx.core.view.WindowInsetsCompat import java.util.logging.Handler class SplashActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) enableEdgeToEdge() setContentView(R.layout.activity_splash); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { val window: Window = this.window window.statusBarColor = this.resources.getColor(R.color.white) } android.os.Handler().postDelayed({ startActivity(Intent(this@SplashActivity, MainActivity::class.java)) }, 2000) ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets -> val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars()) v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom) insets } } }
top-vpn/app/src/main/java/com/example/myapplication/SplashActivity.kt
2795932164
package com.example.navigationtutorial import androidx.test.platform.app.InstrumentationRegistry import androidx.test.ext.junit.runners.AndroidJUnit4 import org.junit.Test import org.junit.runner.RunWith import org.junit.Assert.* /** * Instrumented test, which will execute on an Android device. * * See [testing documentation](http://d.android.com/tools/testing). */ @RunWith(AndroidJUnit4::class) class ExampleInstrumentedTest { @Test fun useAppContext() { // Context of the app under test. val appContext = InstrumentationRegistry.getInstrumentation().targetContext assertEquals("com.example.navigationtutorial", appContext.packageName) } }
Navigation_Tutorial/app/src/androidTest/java/com/example/navigationtutorial/ExampleInstrumentedTest.kt
2079058632
package com.example.navigationtutorial import org.junit.Test import org.junit.Assert.* /** * Example local unit test, which will execute on the development machine (host). * * See [testing documentation](http://d.android.com/tools/testing). */ class ExampleUnitTest { @Test fun addition_isCorrect() { assertEquals(4, 2 + 2) } }
Navigation_Tutorial/app/src/test/java/com/example/navigationtutorial/ExampleUnitTest.kt
2019997500
package com.example.navigationtutorial import androidx.appcompat.app.AppCompatActivity import android.os.Bundle import androidx.navigation.NavController import androidx.navigation.findNavController class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) val navController = findNavController(androidx.navigation.fragment.R.id.nav_host_fragment_container) navController.navigate(R.id.action_fragment1_to_fragment2) } }
Navigation_Tutorial/app/src/main/java/com/example/navigationtutorial/MainActivity.kt
4008776129
package com.example.navigationtutorial import android.os.Bundle import androidx.fragment.app.Fragment import android.view.LayoutInflater import android.view.View import android.view.ViewGroup // TODO: Rename parameter arguments, choose names that match // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER private const val ARG_PARAM1 = "param1" private const val ARG_PARAM2 = "param2" /** * A simple [Fragment] subclass. * Use the [Fragment2.newInstance] factory method to * create an instance of this fragment. */ class Fragment2 : Fragment() { // TODO: Rename and change types of parameters private var param1: String? = null private var param2: String? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) arguments?.let { param1 = it.getString(ARG_PARAM1) param2 = it.getString(ARG_PARAM2) } } override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { // Inflate the layout for this fragment return inflater.inflate(R.layout.fragment_2, container, false) } companion object { /** * Use this factory method to create a new instance of * this fragment using the provided parameters. * * @param param1 Parameter 1. * @param param2 Parameter 2. * @return A new instance of fragment Fragment2. */ // TODO: Rename and change types and number of parameters @JvmStatic fun newInstance(param1: String, param2: String) = Fragment2().apply { arguments = Bundle().apply { putString(ARG_PARAM1, param1) putString(ARG_PARAM2, param2) } } } }
Navigation_Tutorial/app/src/main/java/com/example/navigationtutorial/Fragment2.kt
2575689104
package com.example.navigationtutorial import android.os.Bundle import androidx.fragment.app.Fragment import android.view.LayoutInflater import android.view.View import android.view.ViewGroup // TODO: Rename parameter arguments, choose names that match // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER private const val ARG_PARAM1 = "param1" private const val ARG_PARAM2 = "param2" /** * A simple [Fragment] subclass. * Use the [Fragment1.newInstance] factory method to * create an instance of this fragment. */ class Fragment1 : Fragment() { // TODO: Rename and change types of parameters private var param1: String? = null private var param2: String? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) arguments?.let { param1 = it.getString(ARG_PARAM1) param2 = it.getString(ARG_PARAM2) } } override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { // Inflate the layout for this fragment return inflater.inflate(R.layout.fragment_1, container, false) } companion object { /** * Use this factory method to create a new instance of * this fragment using the provided parameters. * * @param param1 Parameter 1. * @param param2 Parameter 2. * @return A new instance of fragment Fragment1. */ // TODO: Rename and change types and number of parameters @JvmStatic fun newInstance(param1: String, param2: String) = Fragment1().apply { arguments = Bundle().apply { putString(ARG_PARAM1, param1) putString(ARG_PARAM2, param2) } } } }
Navigation_Tutorial/app/src/main/java/com/example/navigationtutorial/Fragment1.kt
3639457409
package com.example.android.politicalpreparedness.database import android.content.Context import androidx.room.Database import androidx.room.Room import androidx.room.RoomDatabase import androidx.room.TypeConverters import com.example.android.politicalpreparedness.network.models.Election @Database(entities = [Election::class], version = 1, exportSchema = false) @TypeConverters(Converters::class) abstract class ElectionDatabase : RoomDatabase() { abstract val electionDao: ElectionDao companion object { @Volatile private var INSTANCE: ElectionDatabase? = null fun getInstance(context: Context): ElectionDatabase { synchronized(this) { var instance = INSTANCE if (instance == null) { instance = Room.databaseBuilder( context.applicationContext, ElectionDatabase::class.java, "election_database" ) .fallbackToDestructiveMigration() .build() INSTANCE = instance } return instance } } } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/database/ElectionDatabase.kt
3123837751
package com.example.android.politicalpreparedness.database import androidx.room.TypeConverter import java.util.* class Converters { @TypeConverter fun fromTimestamp(value: Long?): Date? { return value?.let { Date(it) } } @TypeConverter fun dateToTimestamp(date: Date?): Long? { return date?.time?.toLong() } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/database/Converters.kt
2879155721
package com.example.android.politicalpreparedness.database import androidx.room.Dao import androidx.room.Delete import androidx.room.Insert import androidx.room.OnConflictStrategy import androidx.room.Query import com.example.android.politicalpreparedness.network.models.Election @Dao interface ElectionDao { @Insert(onConflict = OnConflictStrategy.IGNORE) fun insert(election: Election) @Query("SELECT * FROM election_table") fun getAllElections(): List<Election> @Query("SELECT * FROM election_table WHERE id= :electionId") fun getElection(electionId: Int): Election @Delete fun deleteElection(election: Election) @Query("DELETE FROM election_table") fun clear() }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/database/ElectionDao.kt
1653752191
package com.example.android.politicalpreparedness import android.os.Bundle import androidx.appcompat.app.AppCompatActivity class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/MainActivity.kt
2797549734
package com.example.android.politicalpreparedness.launch import android.os.Bundle import android.view.* import androidx.fragment.app.Fragment import androidx.navigation.fragment.findNavController import com.example.android.politicalpreparedness.databinding.FragmentLaunchBinding class LaunchFragment : Fragment() { override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { val binding = FragmentLaunchBinding.inflate(inflater) binding.lifecycleOwner = this binding.representativesBtn.setOnClickListener { navToRepresentatives() } binding.upcomingElectionsBtn.setOnClickListener { navToElections() } return binding.root } private fun navToElections() { this.findNavController() .navigate(LaunchFragmentDirections.actionLaunchFragmentToElectionsFragment()) } private fun navToRepresentatives() { this.findNavController() .navigate(LaunchFragmentDirections.actionLaunchFragmentToRepresentativeFragment()) } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/launch/LaunchFragment.kt
3271487684
package com.example.android.politicalpreparedness.network.models import com.squareup.moshi.JsonClass @JsonClass(generateAdapter = true) data class ElectionResponse( val kind: String, val elections: List<Election> )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/ElectionResponse.kt
1102146445
package com.example.android.politicalpreparedness.network.models data class RepresentativeResponse( val offices: List<Office>, val officials: List<Official> )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/RepresentativeResponse.kt
1534191218
package com.example.android.politicalpreparedness.network.models import android.os.Parcelable import kotlinx.parcelize.Parcelize @Parcelize data class Official( val name: String, val address: List<Address>? = null, val party: String? = null, val phones: List<String>? = null, val urls: List<String>? = null, val photoUrl: String? = null, val channels: List<Channel>? = null ) : Parcelable
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/Official.kt
1203401614
package com.example.android.politicalpreparedness.network.models import com.squareup.moshi.JsonClass @JsonClass(generateAdapter = true) data class AdministrationBody( val name: String? = null, val electionInfoUrl: String? = null, val votingLocationFinderUrl: String? = null, val ballotInfoUrl: String? = null, val correspondenceAddress: Address? = null )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/AdministrationBody.kt
211770384
package com.example.android.politicalpreparedness.network.models data class State( val name: String, val electionAdministrationBody: AdministrationBody )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/State.kt
1438018635
package com.example.android.politicalpreparedness.network.models import com.squareup.moshi.JsonClass @JsonClass(generateAdapter = true) class VoterInfoResponse( val election: Election, val pollingLocations: String? = null, //Future Use //val contests: String? = null, //Future Use val state: List<State>? = null, val electionElectionOfficials: List<ElectionOfficial>? = null )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/VoterInfoResponse.kt
164377711
package com.example.android.politicalpreparedness.network.models import android.os.Parcelable import kotlinx.parcelize.Parcelize @Parcelize data class Address( val line1: String, val line2: String? = null, val city: String, val state: String, val zip: String ) : Parcelable { fun toFormattedString(): String { var output = line1.plus("\n") if (!line2.isNullOrEmpty()) output = output.plus(line2).plus("\n") output = output.plus("$city, $state $zip") return output } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/Address.kt
2204790827
package com.example.android.politicalpreparedness.network.models import android.os.Parcelable import kotlinx.parcelize.Parcelize @Parcelize data class Division( val id: String, val country: String, val state: String ) : Parcelable
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/Division.kt
2689940993
package com.example.android.politicalpreparedness.network.models import android.os.Parcelable import com.example.android.politicalpreparedness.representative.model.Representative import com.squareup.moshi.Json import kotlinx.parcelize.Parcelize @Parcelize data class Office( val name: String, @Json(name = "divisionId") val division: Division, @Json(name = "officialIndices") val officials: List<Int> ) : Parcelable { fun getRepresentatives(officials: List<Official>): List<Representative> { return this.officials.map { index -> Representative(officials[index], this) } } }
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/Office.kt
1092927827
package com.example.android.politicalpreparedness.network.models import androidx.room.* import com.squareup.moshi.* import java.util.* @Entity(tableName = "election_table") data class Election( @PrimaryKey val id: Int, @ColumnInfo(name = "name") val name: String, @ColumnInfo(name = "electionDay") val electionDay: Date, @Embedded(prefix = "division_") @Json(name = "ocdDivisionId") val division: Division )
PoliticalPreparedness-project/app/src/main/java/com/example/android/politicalpreparedness/network/models/Election.kt
3184329934