sorted = new org.cactoos.set.Sorted<>(
(first, second) -> first.compareTo(second),
new IterableOf<>("abc", "bcd", "abc", "ccc", "acd")
);
```
## Funcs and Procs
This is a traditional `foreach` loop:
```java
for (String name : names) {
System.out.printf("Hello, %s!\n", name);
}
```
This is its object-oriented alternative (no streams!):
```java
new And(
n -> {
System.out.printf("Hello, %s!\n", n);
},
names
).value();
```
This is an endless `while/do` loop:
```java
while (!ready) {
System.out.prinln("Still waiting...");
}
```
Here is its object-oriented alternative:
```java
new And(
ready -> {
System.out.println("Still waiting...");
return !ready;
},
new Endless<>(booleanParameter)
).value();
```
## Dates and Times
From our `org.cactoos.time` package.
Our classes are divided in two groups: those that parse strings into date/time objects, and those that format those objects into strings.
For example, this is the traditional way of parsing a string into an [OffsetDateTime](https://docs.oracle.com/javase/8/docs/api/java/time/OffsetDateTime.html):
```java
final OffsetDateTime date = OffsetDateTime.parse("2007-12-03T10:15:30+01:00");
```
Here is its object-oriented alternative (no static method calls!) using `OffsetDateTimeOf`, which is a `Scalar`:
```java
final OffsetDateTime date = new OffsetDateTimeOf("2007-12-03T10:15:30+01:00").value();
```
To format an `OffsetDateTime` into a `Text`:
```java
final OffsetDateTime date = ...;
final String text = new TextOf(date).asString();
```
## Our objects vs. their static methods
Cactoos | Guava | Apache Commons | JDK 8
------ | ------ | ------ | ------
`And` | `Iterables.all()` | - | -
`Filtered` | `Iterables.filter()` | ? | -
`FormattedText` | - | - | `String.format()`
`IsBlank` | - | `StringUtils.isBlank()`| -
`Joined` | - | - | `String.join()`
`LengthOf` | - | - | `String#length()`
`Lowered` | - | - | `String#toLowerCase()`
`Normalized` | - | `StringUtils.normalize()` | -
`Or` | `Iterables.any()` | - | -
`Repeated` | - | `StringUtils.repeat()` | -
`Replaced` | - | - | `String#replace()`
`Reversed` | - | - | `StringBuilder#reverse()`
`Rotated` | - | `StringUtils.rotate()`| -
`Split` | - | - | `String#split()`
`StickyList` | `Lists.newArrayList()` | ? | `Arrays.asList()`
`Sub` | - | - | `String#substring()`
`SwappedCase` | - | `StringUtils.swapCase()` | -
`TextOf` | ? | `IOUtils.toString()` | -
`TrimmedLeft` | - | `StringUtils.stripStart()` | -
`TrimmedRight` | - | `StringUtils.stripEnd()` | -
`Trimmed` | - | `StringUtils.stripAll()` | `String#trim()`
`Upper` | - | - | `String#toUpperCase()`
## Questions
Ask your questions related to cactoos library on [Stackoverflow](https://stackoverflow.com/questions/ask) with [cactoos](https://stackoverflow.com/tags/cactoos/info) tag.
## How to contribute?
Just fork the repo and send us a pull request.
Make sure your branch builds without any warnings/issues:
```
mvn clean verify -Pqulice
```
To run a build similar to the CI with Docker only, use:
```
docker run \
--tty \
--interactive \
--workdir=/main \
--volume=${PWD}:/main \
--volume=cactoos-mvn-cache:/root/.m2 \
--rm \
maven:3-jdk-8 \
bash -c "mvn clean install site -Pqulice -Psite --errors; chown -R $(id -u):$(id -g) target/"
```
To remove the cache used by Docker-based build:
```
docker volume rm cactoos-mvn-cache
```
Note: [Checkstyle](https://en.wikipedia.org/wiki/Checkstyle) is used as a static code analyze tool with
[checks list](http://checkstyle.sourceforge.net/checks.html) in GitHub precommits.
## Contributors
- [@yegor256](https://github.com/yegor256) as Yegor Bugayenko ([Blog](http://www.yegor256.com))
- [@g4s8](https://github.com/g4s8) as Kirill Che. (g4s8.public@gmail.com)
- [@fabriciofx](https://github.com/fabriciofx) as Fabrício Cabral
- [@englishman](https://github.com/englishman) as Andriy Kryvtsun
- [@VsSekorin](https://github.com/VsSekorin) as Vseslav Sekorin
- [@DronMDF](https://github.com/DronMDF) as Andrey Valyaev
- [@dusan-rychnovsky](https://github.com/dusan-rychnovsky) as Dušan Rychnovský ([Blog](http://blog.dusanrychnovsky.cz/))
- [@timmeey](https://github.com/timmeey) as Tim Hinkes ([Blog](https://blog.timmeey.de))
- [@alex-semenyuk](https://github.com/alex-semenyuk) as Alexey Semenyuk
- [@smallcreep](https://github.com/smallcreep) as Ilia Rogozhin
- [@memoyil](https://github.com/memoyil) as Mehmet Yildirim
- [@llorllale](https://github.com/llorllale) as George Aristy
- [@driver733](https://github.com/driver733) as Mikhail Yakushin
- [@izrik](https://github.com/izrik) as Richard Sartor
- [@Vatavuk](https://github.com/Vatavuk) as Vedran Grgo Vatavuk
- [@dgroup](https://github.com/dgroup) as Yurii Dubinka
- [@iakunin](https://github.com/iakunin) as Maksim Iakunin
- [@fanifieiev](https://github.com/fanifieiev) as Fevzi Anifieiev
- [@victornoel](https://github.com/victornoel) as Victor Noël
- [@paulodamaso](https://github.com/paulodamaso) as Paulo Lobo
cactoos-0.49/pom.xml 0000664 0000000 0000000 00000024764 14000546503 0014430 0 ustar 00root root 0000000 0000000
4.0.0
com.jcabi
parent
0.50.5
org.cactoos
cactoos
0.49
jar
cactoos
Object-oriented Java Primitives
https://github.com/yegor256/cactoos
2017
Cactoos
https://github.com/yegor256/cactoos
MIT
https://raw.githubusercontent.com/yegor256/cactoos/master/LICENSE.txt
site
1
Yegor Bugayenko
yegor256@gmail.com
yegor256.com
http://www.yegor256.com
Architect
Developer
-7
GitHub
https://github.com/yegor256/cactoos/issues
scm:git:git@github.com:yegor256/cactoos.git
scm:git:git@github.com:yegor256/cactoos.git
https://github.com/yegor256/cactoos
rultor
http://www.rultor.com/s/cactoos
github-pages
https://github.com/yegor256/cactoos
org.takes
takes
1.1
test
org.llorllale
cactoos-matchers
0.22
test
org.cactoos
cactoos
com.google.code.findbugs
annotations
3.0.1
provided
net.jcip
jcip-annotations
com.google.code.findbugs
jsr305
org.junit.vintage
junit-vintage-engine
test
junit
junit
4.13
test
org.hamcrest
hamcrest-core
1.3
test
org.apache.maven.plugins
maven-verifier-plugin
1.1
main
package
verify
src/verifier/verifications.xml
org.apache.maven.plugins
maven-verifier-plugin
org.jacoco
jacoco-maven-plugin
0.8.6
${project.build.directory}/coverage
jacoco-initialize
prepare-agent
jacoco-check
test
check
report
BUNDLE
INSTRUCTION
COVEREDRATIO
0.61
LINE
COVEREDRATIO
0.65
BRANCH
COVEREDRATIO
0.65
COMPLEXITY
COVEREDRATIO
0.57
METHOD
COVEREDRATIO
0.57
CLASS
MISSEDCOUNT
15
qulice
com.qulice
qulice-maven-plugin
0.18.19
checkstyle:/src/site/resources/.*
de.thetaphi
forbiddenapis
2.6
./src/test/resources/forbidden-apis.txt
org/cactoos/bytes/*.class
org/cactoos/map/*.class
org/cactoos/time/*.class
org/cactoos/collection/*.class
org/cactoos/experimental/*.class
org/cactoos/func/*.class
testCheck
sonar
https://sonarcloud.io
yegor256-github
org.sonarsource.scanner.maven
sonar-maven-plugin
3.7.0.1746
verify
sonar
cactoos-0.49/src/ 0000775 0000000 0000000 00000000000 14000546503 0013665 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/ 0000775 0000000 0000000 00000000000 14000546503 0014611 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/ 0000775 0000000 0000000 00000000000 14000546503 0015532 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/ 0000775 0000000 0000000 00000000000 14000546503 0016321 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/ 0000775 0000000 0000000 00000000000 14000546503 0017754 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/BiFunc.java 0000664 0000000 0000000 00000003513 14000546503 0021767 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
/**
* Function that accepts two arguments.
*
* If you don't want to have any checked exceptions being thrown
* out of your {@link BiFunc}, you can use
* {@link org.cactoos.func.UncheckedBiFunc} decorator. Also
* you may try {@link org.cactoos.func.IoCheckedBiFunc}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of input
* @param Type of output
* @since 0.9
*/
public interface BiFunc {
/**
* Apply it.
* @param first The first argument
* @param second The second argument
* @return The result
* @throws Exception If fails
*/
Z apply(X first, Y second) throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/BiProc.java 0000664 0000000 0000000 00000004161 14000546503 0021777 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import org.cactoos.proc.IoCheckedBiProc;
import org.cactoos.proc.UncheckedBiProc;
/**
* Proc that accepts two arguments.
*
* If you don't want to have any checked exceptions being thrown
* out of your {@link BiProc}, you can use
* {@link UncheckedBiProc} decorator. Also
* you may try {@link IoCheckedBiProc}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of input
* @since 0.20
* @todo #1445:30min Introduce BiProcOf on the model of ProcOf, FuncOf, etc
* with constructors taking Func, BiFunc, Proc and BiProc as primary.
* Add tests similar to those of ProcOfTest, FuncOfTest, etc to fully cover
* the implementation. Use it where needed, for example in AndWithIndexTest.
*/
public interface BiProc {
/**
* Execute it.
* @param first The first argument
* @param second The second argument
* @throws Exception If fails
*/
void exec(X first, Y second) throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Bytes.java 0000664 0000000 0000000 00000002704 14000546503 0021710 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
/**
* Bytes.
*
* There is no thread-safety guarantee.
*
* @see org.cactoos.bytes.BytesOf
* @since 0.1
*/
public interface Bytes {
/**
* Convert it to the byte array.
* @return The byte array
* @throws Exception If fails
*/
byte[] asBytes() throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Fallback.java 0000664 0000000 0000000 00000006710 14000546503 0022322 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import org.cactoos.iterable.IterableOf;
import org.cactoos.iterable.Mapped;
import org.cactoos.scalar.InheritanceLevel;
import org.cactoos.scalar.MinOf;
/**
* Fallback from a {@link Throwable}.
*
*
There is no thread-safety guarantee.
*
* @param Type of input
* @since 1.0
*/
public interface Fallback extends Func {
/**
* Calculate level of support of the given exception type.
* @param exception Exception
* @return Level of support: greater or equals to 0 if the target
* is supported and {@link Integer#MIN_VALUE} otherwise
*/
int support(Throwable exception);
/**
* Fallback from exception.
*
* There is no thread-safety guarantee.
*
* @param Type of result
* @since 1.0
*/
final class From implements Fallback {
/**
* The list of exceptions supported by this instance.
*/
private final Iterable> exceptions;
/**
* Function that converts exceptions to the required type.
*/
private final Func func;
/**
* Ctor.
* @param exp Supported exception type
* @param func Function that converts the given exception into required one
*/
@SuppressWarnings("unchecked")
public From(final Class exp,
final Func func) {
this(new IterableOf<>(exp), func);
}
/**
* Ctor.
* @param exps Supported exceptions types
* @param func Function that converts the given exception into required one
*/
public From(
final Iterable> exps,
final Func func) {
this.exceptions = exps;
this.func = func;
}
@Override
public T apply(final Throwable exp) throws Exception {
return this.func.apply(exp);
}
@Override
public int support(final Throwable exception) {
return new MinOf(
new Mapped<>(
supported -> new InheritanceLevel(exception.getClass(), supported).value(),
this.exceptions
)
).intValue();
}
}
}
cactoos-0.49/src/main/java/org/cactoos/Func.java 0000664 0000000 0000000 00000003767 14000546503 0021527 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
/**
* Function.
*
* If you don't want to have any checked exceptions being thrown
* out of your {@link Func}, you can use
* {@link org.cactoos.func.UncheckedFunc} decorator. Also
* you may try {@link org.cactoos.func.IoCheckedFunc}.
*
* If you want to cache the result of the {@link Func} and
* make sure it doesn't calculate anything twice, you can use
* {@link org.cactoos.func.StickyFunc} decorator.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @see org.cactoos.func.StickyFunc
* @see org.cactoos.func.UncheckedFunc
* @see org.cactoos.func.IoCheckedFunc
* @since 0.1
*/
public interface Func {
/**
* Apply it.
* @param input The argument
* @return The result
* @throws Exception If fails
*/
Y apply(X input) throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Input.java 0000664 0000000 0000000 00000003576 14000546503 0021731 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import java.io.InputStream;
/**
* Input.
*
* Here is for example how {@link Input} can be used
* in order to read the content of a text file:
*
* String content = new TextOf(
* new InputOf(new File("/tmp/names.txt"))
* ).asString();
*
* Here {@link org.cactoos.io.InputOf} implements
* {@link Input} and behaves like
* one, providing read-only access to
* the encapsulated {@link java.io.File}.
*
* There is no thread-safety guarantee.
*
* @see org.cactoos.io.InputOf
* @since 0.1
*/
public interface Input {
/**
* Get read access to it.
* @return InputStream to read from
* @throws Exception If something goes wrong
*/
InputStream stream() throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Output.java 0000664 0000000 0000000 00000004240 14000546503 0022117 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import java.io.OutputStream;
import org.cactoos.io.OutputTo;
import org.cactoos.io.TeeInput;
/**
* Output.
*
*
Here is for example how {@link Output} can be used
* together with {@link Input} in order to modify the content
* of a text file:
*
* new LengthOf(
* new TeeInput(
* new InputOf(new TextOf("Hello, world!")),
* new OutputTo(new File("/tmp/names.txt"))
* )
* ).asValue();
*
* Here {@link OutputTo} implements {@link Output} and behaves like
* one, providing write-only access to the encapsulated
* {@link java.io.File}. The {@link TeeInput} copies the content of the
* input to the output. The {@link org.cactoos.scalar.LengthOf}
* calculates the size of the copied data.
*
* There is no thread-safety guarantee.
*
* @see OutputTo
* @since 0.1
*/
public interface Output {
/**
* Get write access to it.
* @return OutputStream to write to
* @throws Exception If something goes wrong
*/
OutputStream stream() throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Proc.java 0000664 0000000 0000000 00000003350 14000546503 0021523 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import org.cactoos.proc.IoCheckedProc;
import org.cactoos.proc.UncheckedProc;
/**
* Procedure.
*
*
If you don't want to have any checked exceptions being thrown
* out of your {@link Proc}, you can use
* {@link UncheckedProc} decorator. Also
* you may try {@link IoCheckedProc}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @see org.cactoos.func.FuncOf
* @since 0.1
*/
public interface Proc {
/**
* Execute it.
* @param input The argument
* @throws Exception If fails
*/
void exec(X input) throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Scalar.java 0000664 0000000 0000000 00000003662 14000546503 0022033 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
import org.cactoos.scalar.IoChecked;
import org.cactoos.scalar.Sticky;
import org.cactoos.scalar.Unchecked;
/**
* Scalar.
*
* If you don't want to have any checked exceptions being thrown
* out of your {@link Scalar}, you can use
* {@link Unchecked} decorator. Also
* you may try {@link IoChecked}.
*
* If you want to cache the result of the {@link Scalar} and
* make sure it doesn't calculate anything twice, you can use
* {@link Sticky} decorator.
*
* There is no thread-safety guarantee.
*
* @param Type of result
* @see Sticky
* @see Unchecked
* @see IoChecked
* @since 0.1
*/
public interface Scalar {
/**
* Convert it to the value.
* @return The value
* @throws Exception If fails
*/
T value() throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/Text.java 0000664 0000000 0000000 00000003141 14000546503 0021542 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos;
/**
* Text.
*
* If you don't want to have any checked exceptions being thrown
* out of your {@link Text}, you can use
* {@link org.cactoos.text.UncheckedText} decorator.
*
* There is no thread-safety guarantee.
*
* @see org.cactoos.text.TextOf
* @since 0.1
*/
public interface Text {
/**
* Convert it to the string.
* @return The string
* @throws Exception If fails
*/
String asString() throws Exception;
}
cactoos-0.49/src/main/java/org/cactoos/bytes/ 0000775 0000000 0000000 00000000000 14000546503 0021102 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/bytes/Base64Bytes.java 0000664 0000000 0000000 00000004073 14000546503 0024004 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.util.Base64;
import org.cactoos.Bytes;
/**
* Decodes all origin bytes using the Base64 encoding scheme.
*
* @since 0.20.2
*/
public final class Base64Bytes implements Bytes {
/**
* Origin bytes.
*/
private final Bytes origin;
/**
* The decoder.
*/
private final Base64.Decoder decoder;
/**
* Ctor uses a RFC4648 {@link java.util.Base64.Decoder}.
*
* @param origin Origin bytes
*/
public Base64Bytes(final Bytes origin) {
this(origin, Base64.getDecoder());
}
/**
* Ctor.
*
* @param origin Origin bytes.
* @param dec Decoder to use.
*/
public Base64Bytes(final Bytes origin, final Base64.Decoder dec) {
this.origin = origin;
this.decoder = dec;
}
@Override
public byte[] asBytes() throws Exception {
return this.decoder.decode(this.origin.asBytes());
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/BytesBase64.java 0000664 0000000 0000000 00000004110 14000546503 0023774 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.util.Base64;
import org.cactoos.Bytes;
/**
* Encodes all origin bytes using the Base64 encoding scheme.
*
* @since 0.20.2
*/
public final class BytesBase64 implements Bytes {
/**
* Origin bytes.
*/
private final Bytes origin;
/**
* The encoder to use.
*/
private final Base64.Encoder encoder;
/**
* Ctor uses a RFC4648 {@link java.util.Base64.Encoder}.
*
* @param origin Origin bytes.
*/
public BytesBase64(final Bytes origin) {
this(origin, Base64.getEncoder());
}
/**
* Ctor.
*
* @param origin Origin bytes.
* @param enc The encoder to use.
*/
public BytesBase64(final Bytes origin, final Base64.Encoder enc) {
this.origin = origin;
this.encoder = enc;
}
@Override
public byte[] asBytes() throws Exception {
return this.encoder.encode(this.origin.asBytes());
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/BytesOf.java 0000664 0000000 0000000 00000022373 14000546503 0023327 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.cactoos.Bytes;
import org.cactoos.Input;
import org.cactoos.Text;
import org.cactoos.io.InputOf;
import org.cactoos.iterable.IterableOf;
import org.cactoos.list.ListOf;
/**
* A {@link Bytes} that encapsulates other sources of data.
*
*
There is no thread-safety guarantee.
*
* @since 0.12
*/
public final class BytesOf implements Bytes {
/**
* The bytes.
*/
private final Bytes origin;
/**
* Ctor.
* @param input The input
*/
public BytesOf(final Input input) {
this(new InputAsBytes(input));
}
/**
* Ctor.
* @param input The input
* @since 0.29.2
*/
public BytesOf(final InputStream input) {
this(new InputAsBytes(new InputOf(input)));
}
/**
* Ctor.
* @param file The input
* @since 0.13
*/
public BytesOf(final File file) {
this(new InputOf(file));
}
/**
* Ctor.
* @param path The input
* @since 0.13
*/
public BytesOf(final Path path) {
this(new InputOf(path));
}
/**
* Ctor.
* @param input The input
* @param max Max length of the buffer for reading
*/
public BytesOf(final Input input, final int max) {
this(new InputAsBytes(input, max));
}
/**
* Ctor.
* @param rdr Reader
*/
public BytesOf(final Reader rdr) {
this(new ReaderAsBytes(rdr));
}
/**
* Ctor.
* @param rdr Reader
* @param charset Charset
*/
public BytesOf(final Reader rdr, final Charset charset) {
this(new ReaderAsBytes(rdr, charset));
}
/**
* Ctor.
* @param rdr Reader
* @param charset Charset
*/
public BytesOf(final Reader rdr, final CharSequence charset) {
this(new ReaderAsBytes(rdr, charset));
}
/**
* Ctor.
* @param rdr Reader
* @param charset Charset
* @param max Buffer size
*/
public BytesOf(final Reader rdr, final Charset charset, final int max) {
this(new ReaderAsBytes(rdr, charset, max));
}
/**
* Ctor.
* @param rdr Reader
* @param max Buffer size
* @since 0.13.3
*/
public BytesOf(final Reader rdr, final int max) {
this(new ReaderAsBytes(rdr, max));
}
/**
* Ctor.
* @param rdr Reader
* @param charset Charset
* @param max Buffer size
*/
public BytesOf(final Reader rdr, final CharSequence charset,
final int max) {
this(new ReaderAsBytes(rdr, charset, max));
}
/**
* Ctor.
*
* @param input The source
*/
public BytesOf(final CharSequence input) {
this(input, StandardCharsets.UTF_8);
}
/**
* Ctor.
*
* @param input The source
* @param charset The charset
*/
public BytesOf(final CharSequence input, final Charset charset) {
this(() -> input.toString().getBytes(charset));
}
/**
* Ctor.
*
* @param input The source
* @param charset The charset
*/
public BytesOf(final CharSequence input, final CharSequence charset) {
this(() -> input.toString().getBytes(charset.toString()));
}
/**
* Ctor.
*
* @param chars The chars
*/
public BytesOf(final char... chars) {
this(chars, StandardCharsets.UTF_8);
}
/**
* Ctor.
*
* @param chars The chars
* @param charset The charset
*/
public BytesOf(final char[] chars, final Charset charset) {
this(new String(chars), charset);
}
/**
* Ctor.
*
* @param chars The chars
* @param charset The charset
*/
public BytesOf(final char[] chars, final CharSequence charset) {
this(new String(chars), charset);
}
/**
* Ctor.
* @param text The source
*/
public BytesOf(final Text text) {
this(text, StandardCharsets.UTF_8);
}
/**
* Ctor.
* @param text The source
* @param charset The charset
*/
public BytesOf(final Text text, final Charset charset) {
this(() -> text.asString().getBytes(charset));
}
/**
* Ctor.
* @param text The source
* @param charset The charset
*/
public BytesOf(final Text text, final CharSequence charset) {
this(() -> text.asString().getBytes(charset.toString()));
}
/**
* Ctor.
* @param error The exception to serialize
*/
public BytesOf(final Throwable error) {
this(error, StandardCharsets.UTF_8);
}
/**
* Ctor.
* @param error The exception to serialize
* @param charset Charset
*/
public BytesOf(final Throwable error, final Charset charset) {
this(error, charset.name());
}
/**
* Ctor.
* @param error The exception to serialize
* @param charset Charset
*/
public BytesOf(final Throwable error, final CharSequence charset) {
this(
() -> {
try (
ByteArrayOutputStream baos =
new ByteArrayOutputStream()
) {
error.printStackTrace(
new PrintStream(baos, true, charset.toString())
);
return baos.toByteArray();
}
}
);
}
/**
* Ctor.
* @param strace The stack trace
* @since 0.29
*/
public BytesOf(final StackTraceElement... strace) {
this(strace, StandardCharsets.UTF_8);
}
/**
* Ctor.
* @param strace The stack trace
* @param charset Charset
* @since 0.29
*/
public BytesOf(final StackTraceElement[] strace, final Charset charset) {
this(strace, charset.name());
}
/**
* Ctor.
* @param strace The stack trace
* @param charset Charset
* @since 0.29
*/
public BytesOf(final StackTraceElement[] strace,
final CharSequence charset) {
this(
() -> {
try (
ByteArrayOutputStream baos =
new ByteArrayOutputStream();
PrintStream stream = new PrintStream(
baos, true, charset.toString()
)
) {
for (final StackTraceElement element : strace) {
stream.append(element.toString());
stream.append("\n");
}
return baos.toByteArray();
}
}
);
}
/**
* Ctor.
*
* @param bytes Bytes to encapsulate
*/
public BytesOf(final byte... bytes) {
this(() -> bytes);
}
/**
* Ctor.
*
* @param iterator Iterator of bytes
*/
public BytesOf(final Iterator iterator) {
this(new IterableOf<>(iterator));
}
/**
* Ctor.
*
* @param bytes Iterable of bytes
*/
public BytesOf(final Iterable bytes) {
this(() -> {
final List concrete = new ListOf<>(bytes);
final ByteBuffer buf = ByteBuffer.allocate(
concrete.size()
);
concrete.forEach(buf::put);
return buf.array();
});
}
/**
* Ctor.
*
* @param bytes Collection of bytes
*/
public BytesOf(final Collection bytes) {
this(() -> {
final ByteBuffer buf = ByteBuffer.allocate(
bytes.size()
);
bytes.forEach(buf::put);
return buf.array();
});
}
/**
* Ctor.
*
* @param bytes Bytes to encapsulate
*/
private BytesOf(final Bytes bytes) {
this.origin = bytes;
}
@Override
public byte[] asBytes() throws Exception {
return this.origin.asBytes();
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/CheckedBytes.java 0000664 0000000 0000000 00000004030 14000546503 0024277 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Bytes;
import org.cactoos.Func;
import org.cactoos.scalar.Checked;
/**
* Bytes that throws exception of specified type.
*
* @param Exception's type.
* @since 0.31
*/
public final class CheckedBytes implements Bytes {
/**
* Original bytes.
*/
private final Bytes origin;
/**
* Function that wraps exception of {@link #origin} to the required type.
*/
private final Func func;
/**
* Ctor.
* @param orig Origin bytes.
* @param fnc Function that wraps exceptions.
*/
public CheckedBytes(final Bytes orig, final Func fnc) {
this.origin = orig;
this.func = fnc;
}
@Override
public byte[] asBytes() throws E {
return new Checked<>(
this.origin::asBytes,
this.func
).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/DigestEnvelope.java 0000664 0000000 0000000 00000005774 14000546503 0024677 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.cactoos.Bytes;
import org.cactoos.Input;
/**
* Digest Envelope.
*
* There is no thread-safety guarantee.
*
* @since 0.29
* @checkstyle AbstractClassNameCheck (500 lines)
* @checkstyle DesignForExtensionCheck (500 lines)
*/
@SuppressWarnings("PMD.AbstractNaming")
public abstract class DigestEnvelope implements Bytes {
/**
* The input.
*/
private final Input source;
/**
* The buffer size.
*/
private final int size;
/**
* The algorithm.
*/
private final String algorithm;
/**
* Ctor.
* @param input The input
* @param algrthm The algorithm
*/
public DigestEnvelope(final Input input, final String algrthm) {
// @checkstyle MagicNumber (1 line)
this(input, 16 << 10, algrthm);
}
/**
* Ctor.
* @param input The input
* @param max Buffer size
* @param algrthm The algorithm
*/
public DigestEnvelope(
final Input input,
final int max,
final String algrthm
) {
this.source = input;
this.size = max;
this.algorithm = algrthm;
}
@Override
public byte[] asBytes() throws Exception {
try (InputStream stream = this.source.stream()) {
final MessageDigest msg = MessageDigest.getInstance(this.algorithm);
final byte[] buf = new byte[this.size];
while (true) {
final int len = stream.read(buf);
if (len < 0) {
break;
}
msg.update(buf, 0, len);
}
return msg.digest();
} catch (final NoSuchAlgorithmException ex) {
throw new IOException(ex);
}
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/EmptyBytes.java 0000664 0000000 0000000 00000002771 14000546503 0024061 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Bytes;
/**
* Bytes with no data.
*
*
There is no thread-safety guarantee.
*
* @since 0.2
*/
public final class EmptyBytes implements Bytes {
/**
* Empty array of bytes.
*/
private static final byte[] EMPTY = {};
@Override
public byte[] asBytes() {
return EmptyBytes.EMPTY;
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/HexOf.java 0000664 0000000 0000000 00000005756 14000546503 0022773 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.Iterator;
import org.cactoos.Bytes;
import org.cactoos.Text;
import org.cactoos.iterator.Mapped;
import org.cactoos.text.FormattedText;
/**
* Decodes origin {@link Text} using the hexadecimal encoding scheme.
*
* @since 0.30
* @checkstyle MagicNumberCheck (500 lines)
*/
public final class HexOf implements Bytes {
/**
* Origin hexadecimal text.
*/
private final Text origin;
/**
* Ctor.
*
* @param origin Hexadecimal text.
*/
public HexOf(final Text origin) {
this.origin = origin;
}
@Override
public byte[] asBytes() throws Exception {
final String hex = this.origin.asString();
if ((hex.length() & 1) == 1) {
throw new IOException("Length of hexadecimal text is odd");
}
final Iterator iter = new Mapped<>(
c -> {
final int result = Character.digit(c, 16);
if (result == -1) {
throw new IOException(
new FormattedText(
"Unexpected character '%c'",
c
).asString()
);
}
return result;
},
hex.chars().mapToObj(c -> (char) c).iterator()
);
final byte[] result = new byte[hex.length() / 2];
int index = 0;
while (index < hex.length()) {
try {
final int most = iter.next();
final int less = iter.next();
result[index >>> 1] = (byte) ((most << 4) + less);
index += 2;
} catch (final UncheckedIOException ex) {
throw ex.getCause();
}
}
return result;
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/InputAsBytes.java 0000664 0000000 0000000 00000005145 14000546503 0024344 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import org.cactoos.Bytes;
import org.cactoos.Input;
import org.cactoos.io.OutputTo;
import org.cactoos.io.TeeInput;
/**
* Input as Byte Array.
*
* This class is for internal use only. Use {@link BytesOf} instead.
*
* There is no thread-safety guarantee.
* @since 0.1
*/
public final class InputAsBytes implements Bytes {
/**
* The input.
*/
private final Input source;
/**
* The buffer size.
*/
private final int size;
/**
* Ctor.
* @param input The input
*/
InputAsBytes(final Input input) {
// @checkstyle MagicNumber (1 line)
this(input, 16 << 10);
}
/**
* Ctor.
* @param input The input
* @param max Max length of the buffer for reading
*/
InputAsBytes(final Input input, final int max) {
this.source = input;
this.size = max;
}
@Override
public byte[] asBytes() throws Exception {
try (
ByteArrayOutputStream baos = new ByteArrayOutputStream();
InputStream stream = new TeeInput(
this.source,
new OutputTo(baos)
).stream()
) {
final byte[] buf = new byte[this.size];
while (true) {
if (stream.read(buf) < 0) {
break;
}
}
return baos.toByteArray();
}
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/Md5DigestOf.java 0000664 0000000 0000000 00000003414 14000546503 0024021 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Input;
/**
* MD5 checksum calculation of {@link Input}.
*
*
There is no thread-safety guarantee.
*
* @since 0.29
*/
@SuppressWarnings("PMD.AvoidDuplicateLiterals")
public final class Md5DigestOf extends DigestEnvelope {
/**
* Ctor.
* @param input The input
*/
public Md5DigestOf(final Input input) {
super(input, "MD5");
}
/**
* Ctor.
* @param input The input
* @param max Buffer size
*/
public Md5DigestOf(final Input input, final int max) {
// @checkstyle MagicNumber (1 line)
super(input, max, "MD5");
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/NoNulls.java 0000664 0000000 0000000 00000003654 14000546503 0023347 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Bytes;
/**
* Bytes check for no nulls.
*
* @since 0.11
*/
public final class NoNulls implements Bytes {
/**
* The input.
*/
private final Bytes origin;
/**
* Ctor.
* @param bytes The input
*/
public NoNulls(final Bytes bytes) {
this.origin = bytes;
}
@Override
public byte[] asBytes() throws Exception {
if (this.origin == null) {
throw new IllegalArgumentException(
"NULL instead of a valid bytes"
);
}
final byte[] bytes = this.origin.asBytes();
if (bytes == null) {
throw new IllegalStateException(
"NULL instead of a valid byte array"
);
}
return bytes;
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/ReaderAsBytes.java 0000664 0000000 0000000 00000007045 14000546503 0024450 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import java.io.Reader;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import org.cactoos.Bytes;
/**
* Reader as {@link Bytes}.
*
*
This class is for internal use only. Use {@link BytesOf} instead.
*
* There is no thread-safety guarantee.
*
* @since 0.12
*/
final class ReaderAsBytes implements Bytes {
/**
* The reader.
*/
private final Reader reader;
/**
* The charset.
*/
private final CharSequence charset;
/**
* The buffer size.
*/
private final int size;
/**
* Ctor.
*
* @param rdr Reader
*/
ReaderAsBytes(final Reader rdr) {
this(rdr, StandardCharsets.UTF_8);
}
/**
* Ctor.
*
* @param rdr Reader
* @param cset Charset
*/
ReaderAsBytes(final Reader rdr, final Charset cset) {
// @checkstyle MagicNumber (1 line)
this(rdr, cset, 16 << 10);
}
/**
* Ctor.
*
* @param rdr Reader
* @param cset Charset
* @since 0.13.2
*/
ReaderAsBytes(final Reader rdr, final CharSequence cset) {
// @checkstyle MagicNumber (1 line)
this(rdr, cset, 16 << 10);
}
/**
* Ctor.
*
* @param rdr Reader
* @param cset Charset
* @param max Buffer size
*/
ReaderAsBytes(final Reader rdr, final Charset cset, final int max) {
this(rdr, cset.name(), max);
}
/**
* Ctor.
* @param rdr Reader
* @param max Buffer size
* @since 0.13.3
*/
ReaderAsBytes(final Reader rdr, final int max) {
this(rdr, StandardCharsets.UTF_8, max);
}
/**
* Ctor.
*
* @param rdr Reader
* @param cset Charset
* @param max Buffer size
*/
ReaderAsBytes(final Reader rdr, final CharSequence cset, final int max) {
this.reader = rdr;
this.charset = cset;
this.size = max;
}
@Override
public byte[] asBytes() throws Exception {
final char[] buffer = new char[this.size];
final StringBuilder builder = new StringBuilder(this.size);
while (true) {
final int done = this.reader.read(buffer, 0, buffer.length);
if (done < 0) {
break;
}
builder.append(buffer, 0, done);
}
this.reader.close();
return builder.toString().getBytes(this.charset.toString());
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/Sha1DigestOf.java 0000664 0000000 0000000 00000003425 14000546503 0024172 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Input;
/**
* SHA-1 checksum calculation of {@link Input}.
*
*
There is no thread-safety guarantee.
*
* @since 0.29
*/
@SuppressWarnings("PMD.AvoidDuplicateLiterals")
public final class Sha1DigestOf extends DigestEnvelope {
/**
* Ctor.
* @param input The input
*/
public Sha1DigestOf(final Input input) {
super(input, "SHA-1");
}
/**
* Ctor.
* @param input The input
* @param max Buffer size
*/
public Sha1DigestOf(final Input input, final int max) {
// @checkstyle MagicNumber (1 line)
super(input, max, "SHA-1");
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/Sha256DigestOf.java 0000664 0000000 0000000 00000003441 14000546503 0024344 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Input;
/**
* SHA-256 checksum calculation of {@link Input}.
*
*
There is no thread-safety guarantee.
*
* @since 0.29
*/
@SuppressWarnings("PMD.AvoidDuplicateLiterals")
public final class Sha256DigestOf extends DigestEnvelope {
/**
* Ctor.
* @param input The input
*/
public Sha256DigestOf(final Input input) {
super(input, "SHA-256");
}
/**
* Ctor.
* @param input The input
* @param max Buffer size
*/
public Sha256DigestOf(final Input input, final int max) {
// @checkstyle MagicNumber (1 line)
super(input, max, "SHA-256");
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/UncheckedBytes.java 0000664 0000000 0000000 00000004774 14000546503 0024661 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.bytes;
import org.cactoos.Bytes;
import org.cactoos.Func;
import org.cactoos.func.UncheckedFunc;
/**
* Bytes that doesn't throw checked {@link Exception}.
*
*
There is no thread-safety guarantee.
*
* @since 0.3
*/
public final class UncheckedBytes implements Bytes {
/**
* Original bytes.
*/
private final Bytes bytes;
/**
* Fallback.
*/
private final Func fallback;
/**
* Ctor.
* @param bts Encapsulated bytes
*/
@SuppressWarnings("PMD.AvoidThrowingRawExceptionTypes")
public UncheckedBytes(final Bytes bts) {
this(
bts,
error -> {
throw new RuntimeException(error);
}
);
}
/**
* Ctor.
* @param bts Encapsulated bytes
* @param fbk Fallback
* @since 0.5
*/
public UncheckedBytes(final Bytes bts,
final Func fbk) {
this.bytes = bts;
this.fallback = fbk;
}
@Override
@SuppressWarnings("PMD.AvoidCatchingGenericException")
public byte[] asBytes() {
byte[] data;
try {
data = this.bytes.asBytes();
// @checkstyle IllegalCatchCheck (1 line)
} catch (final Exception ex) {
data = new UncheckedFunc<>(this.fallback).apply(ex);
}
return data;
}
}
cactoos-0.49/src/main/java/org/cactoos/bytes/package-info.java 0000664 0000000 0000000 00000002304 14000546503 0024270 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* Bytes.
*
* @since 0.20.2
*/
package org.cactoos.bytes;
cactoos-0.49/src/main/java/org/cactoos/collection/ 0000775 0000000 0000000 00000000000 14000546503 0022107 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/collection/CollectionEnvelope.java 0000664 0000000 0000000 00000005762 14000546503 0026555 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.collection;
import java.util.Collection;
import org.cactoos.iterable.IterableEnvelope;
/**
* Base collection.
*
* There is no thread-safety guarantee.
* @param Element type
* @since 0.23
*/
public abstract class CollectionEnvelope
extends IterableEnvelope implements Collection {
/**
* The wrapped collection.
*/
private final Collection col;
/**
* Ctor.
* @param col The wrapped collection
*/
public CollectionEnvelope(final Collection col) {
super(col);
this.col = col;
}
@Override
public final int size() {
return this.col.size();
}
@Override
public final boolean isEmpty() {
return this.col.isEmpty();
}
@Override
public final boolean contains(final Object object) {
return this.col.contains(object);
}
@Override
public final Object[] toArray() {
return this.col.toArray();
}
@Override
public final T[] toArray(final T[] array) {
return this.col.toArray(array);
}
@Override
public final boolean add(final X item) {
return this.col.add(item);
}
@Override
public final boolean remove(final Object object) {
return this.col.remove(object);
}
@Override
public final boolean containsAll(final Collection list) {
return this.col.containsAll(list);
}
@Override
public final boolean addAll(final Collection list) {
return this.col.addAll(list);
}
@Override
public final boolean removeAll(final Collection list) {
return this.col.removeAll(list);
}
@Override
public final boolean retainAll(final Collection list) {
return this.col.retainAll(list);
}
@Override
public final void clear() {
this.col.clear();
}
}
cactoos-0.49/src/main/java/org/cactoos/collection/Immutable.java 0000664 0000000 0000000 00000010073 14000546503 0024672 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.collection;
import java.util.Collection;
import java.util.Iterator;
/**
* Decorator that doesn't allow any mutation of the wrapped {@link Collection}.
*
* There is no thread-safety guarantee.
*
* @param Type of source item
* @since 1.16
* @todo #898:30min Replace all the Collections.unmodifiableCollection
* with the {@link org.cactoos.collection.Immutable} from the cactoos codebase.
* That should be done because Elegant Object principles are against static methods.
*/
@SuppressWarnings(
{
"PMD.TooManyMethods",
"PMD.AbstractNaming"
}
)
public final class Immutable implements Collection {
/**
* Original collection.
*/
private final Collection col;
/**
* Ctor.
* @param src Source collection
*/
public Immutable(final Collection src) {
this.col = src;
}
@Override
public int size() {
return this.col.size();
}
@Override
public boolean isEmpty() {
return this.col.isEmpty();
}
@Override
public Iterator iterator() {
return this.col.iterator();
}
@Override
public boolean contains(final Object object) {
return this.col.contains(object);
}
@Override
public Object[] toArray() {
return this.col.toArray();
}
@Override
@SuppressWarnings("PMD.UseVarargs")
public T[] toArray(final T[] array) {
return this.col.toArray(array);
}
@Override
public boolean add(final X item) {
throw new UnsupportedOperationException(
"#add(): the collection is read-only"
);
}
@Override
public boolean remove(final Object object) {
throw new UnsupportedOperationException(
"#remove(): the collection is read-only"
);
}
@Override
public boolean containsAll(final Collection list) {
return this.col.containsAll(list);
}
@Override
public boolean addAll(final Collection list) {
throw new UnsupportedOperationException(
"#addAll(): the collection is read-only"
);
}
@Override
public boolean removeAll(final Collection list) {
throw new UnsupportedOperationException(
"#removeAll(): the collection is read-only"
);
}
@Override
public boolean retainAll(final Collection list) {
throw new UnsupportedOperationException(
"#retainAll(): the collection is read-only"
);
}
@Override
public void clear() {
throw new UnsupportedOperationException(
"#clear(): the collection is read-only"
);
}
@Override
public String toString() {
return this.col.toString();
}
@Override
public int hashCode() {
return this.col.hashCode();
}
@Override
public boolean equals(final Object obj) {
return this.col.equals(obj);
}
}
cactoos-0.49/src/main/java/org/cactoos/collection/NoNulls.java 0000664 0000000 0000000 00000011351 14000546503 0024345 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.collection;
import java.util.Collection;
import java.util.Iterator;
import org.cactoos.text.FormattedText;
import org.cactoos.text.UncheckedText;
/**
* A decorator of {@link Collection} that tolerates no NULLs.
*
* There is no thread-safety guarantee.
*
* @param Element type
* @since 0.27
*/
@SuppressWarnings("PMD.TooManyMethods")
public final class NoNulls implements Collection {
/**
* Original collection.
*/
private final Collection col;
/**
* Ctor.
* @param items Original one
*/
public NoNulls(final Collection items) {
this.col = items;
}
@Override
public int size() {
return this.col.size();
}
@Override
public boolean isEmpty() {
return this.col.isEmpty();
}
@Override
public Iterator iterator() {
return new org.cactoos.iterator.NoNulls(this.col.iterator());
}
@Override
public boolean contains(final Object item) {
if (item == null) {
throw new IllegalArgumentException(
"Argument of #contains(T) is NULL"
);
}
return this.col.contains(item);
}
@Override
public Object[] toArray() {
final Object[] array = this.col.toArray();
for (int idx = 0; idx < array.length; ++idx) {
if (array[idx] == null) {
throw new IllegalStateException(
new UncheckedText(
new FormattedText(
"Item #%d of #toArray() is NULL", idx
)
).asString()
);
}
}
return array;
}
@Override
@SuppressWarnings("PMD.UseVarargs")
public T[] toArray(final T[] array) {
this.col.toArray((Object[]) array);
for (int idx = 0; idx < array.length; ++idx) {
if (array[idx] == null) {
throw new IllegalStateException(
new UncheckedText(
new FormattedText(
"Item #%d of #toArray(array) is NULL", idx
)
).asString()
);
}
}
return array;
}
@Override
public boolean add(final X item) {
if (item == null) {
throw new IllegalStateException(
"Item of #add(T) is NULL"
);
}
return this.col.add(item);
}
@Override
public boolean remove(final Object item) {
if (item == null) {
throw new IllegalStateException(
"Item of #remove(T) is NULL"
);
}
return this.col.remove(item);
}
@Override
public boolean containsAll(final Collection items) {
return this.col.containsAll(new NoNulls<>(items));
}
@Override
public boolean addAll(final Collection items) {
return this.col.addAll(new NoNulls<>(items));
}
@Override
public boolean removeAll(final Collection items) {
return this.col.removeAll(new NoNulls<>(items));
}
@Override
public boolean retainAll(final Collection items) {
return this.col.retainAll(new NoNulls<>(items));
}
@Override
public void clear() {
this.col.clear();
}
@Override
public String toString() {
return this.col.toString();
}
@Override
public boolean equals(final Object obj) {
return this.col.equals(obj);
}
@Override
public int hashCode() {
return this.col.hashCode();
}
}
cactoos-0.49/src/main/java/org/cactoos/collection/package-info.java 0000664 0000000 0000000 00000002324 14000546503 0025277 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* Collections, tests.
*
* @since 0.14
*/
package org.cactoos.collection;
cactoos-0.49/src/main/java/org/cactoos/experimental/ 0000775 0000000 0000000 00000000000 14000546503 0022451 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/experimental/Threads.java 0000664 0000000 0000000 00000007532 14000546503 0024715 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.experimental;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.cactoos.Func;
import org.cactoos.Scalar;
import org.cactoos.func.UncheckedFunc;
import org.cactoos.iterable.IterableEnvelope;
import org.cactoos.iterable.IterableOf;
import org.cactoos.iterable.Mapped;
import org.cactoos.list.ListOf;
import org.cactoos.scalar.CallableOf;
/**
* Allows to execute the tasks concurrently.
*
* @param The type of task result item.
* @since 1.0.0
*/
public final class Threads extends IterableEnvelope {
/**
* Ctor.
* @param exc The executor.
* @param tasks The tasks to be executed concurrently.
*/
@SafeVarargs
public Threads(final ExecutorService exc, final Scalar... tasks) {
this(exc, new IterableOf<>(tasks));
}
/**
* Ctor.
* @param exc The executor.
* @param tasks The tasks to be executed concurrently.
*/
public Threads(final ExecutorService exc, final Iterable> tasks) {
this(input -> exc.invokeAll(new ListOf<>(input)), tasks);
}
/**
* Ctor.
* @param threads The quantity of threads which will be used within the
* {@link ExecutorService}.
* @param tasks The tasks to be executed concurrently.
* @see Executors#newFixedThreadPool(int)
*/
@SafeVarargs
public Threads(final int threads, final Scalar... tasks) {
this(threads, new IterableOf<>(tasks));
}
/**
* Ctor.
* @param threads The quantity of threads which will be used within the
* {@link ExecutorService}.
* @param tasks The tasks to be executed concurrently.
* @checkstyle IndentationCheck (20 lines)
*/
public Threads(final int threads, final Iterable> tasks) {
this(
todo -> {
final ExecutorService executor = Executors.newFixedThreadPool(
threads
);
try {
return executor.invokeAll(new ListOf<>(todo));
} finally {
executor.shutdown();
}
},
tasks
);
}
/**
* Ctor.
* @param fnc The function to map each task into {@link Future}.
* @param tasks The tasks to be executed concurrently.
*/
private Threads(
final Func>, Iterable>> fnc,
final Iterable> tasks
) {
super(
() -> new Mapped<>(
Future::get,
new UncheckedFunc<>(fnc).apply(new Mapped<>(CallableOf::new, tasks))
).iterator()
);
}
}
cactoos-0.49/src/main/java/org/cactoos/experimental/Timed.java 0000664 0000000 0000000 00000011623 14000546503 0024361 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.experimental;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import org.cactoos.Func;
import org.cactoos.Scalar;
import org.cactoos.func.UncheckedFunc;
import org.cactoos.iterable.IterableEnvelope;
import org.cactoos.iterable.IterableOf;
import org.cactoos.iterable.Mapped;
import org.cactoos.list.ListOf;
import org.cactoos.scalar.CallableOf;
/**
* Allows to execute the tasks concurrently within given timeout.
*
* @param The type of task result item.
* @since 1.0.0
*/
public final class Timed extends IterableEnvelope {
/**
* Ctor.
* @param exc The executor.
* @param timeout The maximum time to wait.
* @param unit The time unit of the timeout argument.
* @param tasks The tasks to be executed concurrently.
* @checkstyle ParameterNumberCheck (5 lines)
*/
@SafeVarargs
public Timed(
final ExecutorService exc,
final long timeout,
final TimeUnit unit,
final Scalar... tasks
) {
this(exc, new IterableOf<>(tasks), timeout, unit);
}
/**
* Ctor.
* @param exc The executor.
* @param tasks The tasks to be executed concurrently.
* @param timeout The maximum time to wait.
* @param unit The time unit of the timeout argument.
* @checkstyle ParameterNumberCheck (5 lines)
*/
public Timed(
final ExecutorService exc,
final Iterable> tasks,
final long timeout,
final TimeUnit unit
) {
this(
input -> exc.invokeAll(new ListOf<>(input), timeout, unit),
tasks
);
}
/**
* Ctor.
* @param threads The quantity of threads which will be used within the
* {@link ExecutorService}.
* @param timeout The maximum time to wait.
* @param unit The time unit of the timeout argument.
* @param tasks The tasks to be executed concurrently.
* @see Executors#newFixedThreadPool(int)
* @checkstyle ParameterNumberCheck (5 lines)
*/
@SafeVarargs
public Timed(
final int threads,
final long timeout,
final TimeUnit unit,
final Scalar... tasks
) {
this(threads, new IterableOf<>(tasks), timeout, unit);
}
/**
* Ctor.
* @param threads The quantity of threads which will be used within the
* {@link ExecutorService}.
* @param tasks The tasks to be executed concurrently.
* @param timeout The maximum time to wait.
* @param unit The time unit of the timeout argument.
* @checkstyle IndentationCheck (20 lines)
* @checkstyle ParameterNumberCheck (5 lines)
*/
public Timed(
final int threads,
final Iterable> tasks,
final long timeout,
final TimeUnit unit
) {
this(
todo -> {
final ExecutorService executor = Executors.newFixedThreadPool(
threads
);
try {
return executor.invokeAll(new ListOf<>(todo), timeout, unit);
} finally {
executor.shutdown();
}
},
tasks
);
}
/**
* Ctor.
* @param fnc The function to map each task into {@link Future}.
* @param tasks The tasks to be executed concurrently.
*/
private Timed(
final Func>, Iterable>> fnc,
final Iterable> tasks
) {
super(
() -> new Mapped<>(
Future::get,
new UncheckedFunc<>(fnc).apply(new Mapped<>(CallableOf::new, tasks))
).iterator()
);
}
}
cactoos-0.49/src/main/java/org/cactoos/experimental/package-info.java 0000664 0000000 0000000 00000003113 14000546503 0025636 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* We are running experiments with the APIs provided in this package. We
* encourage you to try them out and submit any questions and feedback
* here.
*
* Be warned, however, that the stability of this package is
* not guaranteed.
* APIs may come, change, and go, between any release, for any reason
* whatsoever.
*
* @since 1.0.0
*/
package org.cactoos.experimental;
cactoos-0.49/src/main/java/org/cactoos/func/ 0000775 0000000 0000000 00000000000 14000546503 0020707 5 ustar 00root root 0000000 0000000 cactoos-0.49/src/main/java/org/cactoos/func/Async.java 0000664 0000000 0000000 00000005446 14000546503 0022640 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import org.cactoos.Func;
import org.cactoos.Proc;
/**
* Func that runs in the background.
*
* If you want your piece of code to be executed in the background,
* use {@link Async} as following:
*
* int length = new AsyncFunc(
* input -> input.length()
* ).apply("Hello, world!").get();
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.10
*/
public final class Async implements Func>, Proc {
/**
* The func.
*/
private final Func func;
/**
* The executor service.
*/
private final ExecutorService executor;
/**
* Ctor.
* @param fnc The func
*/
public Async(final Func fnc) {
this(fnc, Executors.defaultThreadFactory());
}
/**
* Ctor.
* @param fnc The func
* @param fct Factory
*/
public Async(final Func fnc, final ThreadFactory fct) {
this(fnc, Executors.newSingleThreadExecutor(fct));
}
/**
* Ctor.
* @param fnc The func
* @param exec Executor Service
*/
public Async(final Func fnc, final ExecutorService exec) {
this.func = fnc;
this.executor = exec;
}
@Override
public Future apply(final X input) {
return this.executor.submit(
() -> this.func.apply(input)
);
}
@Override
public void exec(final X input) {
this.apply(input);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/BiFuncNoNulls.java 0000664 0000000 0000000 00000004626 14000546503 0024243 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.BiFunc;
/**
* BiFunc check for no nulls.
*
* @param Type of input
* @param Type of input
* @param Type of output
* @since 0.11
*/
public final class BiFuncNoNulls implements BiFunc {
/**
* The function.
*/
private final BiFunc origin;
/**
* Ctor.
* @param func The function
*/
public BiFuncNoNulls(final BiFunc func) {
this.origin = func;
}
@Override
public Z apply(final X first, final Y second) throws Exception {
if (this.origin == null) {
throw new IllegalArgumentException(
"NULL instead of a valid function"
);
}
if (first == null) {
throw new IllegalArgumentException(
"NULL instead of a valid first argument"
);
}
if (second == null) {
throw new IllegalArgumentException(
"NULL instead of a valid second argument"
);
}
final Z result = this.origin.apply(first, second);
if (result == null) {
throw new IllegalStateException(
"NULL instead of a valid result"
);
}
return result;
}
}
cactoos-0.49/src/main/java/org/cactoos/func/BiFuncOf.java 0000664 0000000 0000000 00000005460 14000546503 0023212 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.BiFunc;
import org.cactoos.BiProc;
import org.cactoos.Func;
import org.cactoos.Proc;
import org.cactoos.Scalar;
/**
* Represents many possible inputs as {@link BiFunc}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of input
* @param Type of output
* @since 0.20
*/
public final class BiFuncOf implements BiFunc {
/**
* The func.
*/
private final BiFunc func;
/**
* Ctor.
* @param scalar The scalar
*/
public BiFuncOf(final Scalar scalar) {
this((first, second) -> scalar.value());
}
/**
* Ctor.
* @param fnc The func
*/
public BiFuncOf(final Func fnc) {
this((first, second) -> fnc.apply(first));
}
/**
* Ctor.
* @param proc The proc
* @param result Result to return
*/
public BiFuncOf(final Proc proc, final Z result) {
this(
(first, second) -> {
proc.exec(first);
return result;
}
);
}
/**
* Ctor.
* @param proc The proc
* @param result Result to return
*/
public BiFuncOf(final BiProc proc, final Z result) {
this(
(first, second) -> {
proc.exec(first, second);
return result;
}
);
}
/**
* Ctor.
* @param fnc Func
*/
public BiFuncOf(final BiFunc fnc) {
this.func = fnc;
}
@Override
public Z apply(final X first, final Y second) throws Exception {
return this.func.apply(first, second);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/Chained.java 0000664 0000000 0000000 00000004636 14000546503 0023116 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.util.Collections;
import org.cactoos.Func;
/**
* Composed function.
*
* @param Type of input.
* @param Intermediate type.
* @param Type of output.
* @since 0.7
*/
public final class Chained implements Func {
/**
* Before function.
*/
private final Func before;
/**
* Functions.
*/
private final Iterable> funcs;
/**
* After function.
*/
private final Func after;
/**
* Ctor.
* @param bfr Before function
* @param list Functions
* @param atr After function
*/
public Chained(final Func bfr, final Iterable> list,
final Func atr) {
this.before = bfr;
this.funcs = list;
this.after = atr;
}
/**
* Ctor.
* @param bfr Before function
* @param atr After function
*/
public Chained(final Func bfr, final Func atr) {
this(bfr, Collections.emptyList(), atr);
}
@Override
public Z apply(final X input) throws Exception {
Y temp = this.before.apply(input);
for (final Func func : this.funcs) {
temp = func.apply(temp);
}
return this.after.apply(temp);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/CheckedBiFunc.java 0000664 0000000 0000000 00000004331 14000546503 0024170 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.BiFunc;
import org.cactoos.Func;
import org.cactoos.scalar.Checked;
/**
* BiFunc that throws exception of specified type.
*
* @param Type of input
* @param Type of input
* @param Type of output
* @param Exception's type
* @since 0.32
*/
public final class CheckedBiFunc implements
BiFunc {
/**
* Original BiFunc.
*/
private final BiFunc origin;
/**
* Function that wraps exception of {@link #origin} to the required type.
*/
private final Func func;
/**
* Ctor.
* @param original Original BiFunc
* @param fnc Function that wraps exceptions.
*/
public CheckedBiFunc(final BiFunc original,
final Func fnc) {
this.origin = original;
this.func = fnc;
}
@Override
public Z apply(final X first, final Y second) throws E {
return new Checked<>(
() -> this.origin.apply(first, second),
this.func
).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/func/CheckedFunc.java 0000664 0000000 0000000 00000004156 14000546503 0023722 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
import org.cactoos.scalar.Checked;
/**
* Func that throws exception of specified type.
*
* @param Type of input
* @param Type of output
* @param Exception's type
* @since 0.32
*/
public final class CheckedFunc implements
Func {
/**
* Original func.
*/
private final Func origin;
/**
* Function that wraps exception of {@link #origin} to the required type.
*/
private final Func func;
/**
* Ctor.
* @param original Original func
* @param fnc Function that wraps exceptions.
*/
public CheckedFunc(final Func original,
final Func fnc) {
this.origin = original;
this.func = fnc;
}
@Override
public Y apply(final X input) throws E {
return new Checked<>(
() -> this.origin.apply(input),
this.func
).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/func/Flattened.java 0000664 0000000 0000000 00000003152 14000546503 0023461 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
import org.cactoos.Scalar;
/**
* {@link Func} from {@link Func} of {@link Scalar}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.48
*/
public final class Flattened extends FuncEnvelope {
/**
* Ctor.
* @param sclr The func
*/
public Flattened(final Func> sclr) {
super(x -> sclr.apply(x).value());
}
}
cactoos-0.49/src/main/java/org/cactoos/func/FuncEnvelope.java 0000664 0000000 0000000 00000003351 14000546503 0024145 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
/**
* Envelope for Func.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.41
*/
public abstract class FuncEnvelope implements Func {
/**
* The delegate function.
*/
private final Func func;
/**
* Ctor.
* @param func The function
*/
public FuncEnvelope(final Func func) {
this.func = func;
}
@Override
public final Y apply(final X input) throws Exception {
return this.func.apply(input);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/FuncNoNulls.java 0000664 0000000 0000000 00000004206 14000546503 0023762 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.io.IOException;
import org.cactoos.Func;
/**
* Func check for no nulls.
*
* @param Type of input
* @param Type of output
* @since 0.10
*/
public final class FuncNoNulls implements Func {
/**
* The function.
*/
private final Func func;
/**
* Ctor.
* @param fnc The function
*/
public FuncNoNulls(final Func fnc) {
this.func = fnc;
}
@Override
public Y apply(final X input) throws Exception {
if (this.func == null) {
throw new IllegalArgumentException(
"NULL instead of a valid function"
);
}
if (input == null) {
throw new IllegalArgumentException(
"NULL instead of a valid input"
);
}
final Y result = this.func.apply(input);
if (result == null) {
throw new IOException("NULL instead of a valid result");
}
return result;
}
}
cactoos-0.49/src/main/java/org/cactoos/func/FuncOf.java 0000664 0000000 0000000 00000004305 14000546503 0022734 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
import org.cactoos.Proc;
import org.cactoos.Scalar;
/**
* Represents many possible inputs as {@link Func}.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.12
*/
public final class FuncOf implements Func {
/**
* The func.
*/
private final Func func;
/**
* Ctor.
* @param proc The proc
* @param result Result to return
*/
public FuncOf(final Proc proc, final Y result) {
this(
input -> {
proc.exec(input);
return result;
}
);
}
/**
* Ctor.
* @param scalar Origin scalar
*/
public FuncOf(final Scalar scalar) {
this(input -> scalar.value());
}
/**
* Ctor.
* @param fnc Func
*/
public FuncOf(final Func fnc) {
this.func = fnc;
}
@Override
public Y apply(final X input) throws Exception {
return this.func.apply(input);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/FuncWithFallback.java 0000664 0000000 0000000 00000010510 14000546503 0024716 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.sql.SQLException;
import java.sql.SQLRecoverableException;
import org.cactoos.Fallback;
import org.cactoos.Func;
import org.cactoos.iterable.IterableOf;
import org.cactoos.scalar.InheritanceLevel;
import org.cactoos.scalar.ScalarWithFallback;
/**
* Func with fallbacks that enable it to recover from errors.
*
* You may register several fallbacks, each for any type of exception
* whatsoever. If the decorated {@link Func} throws an exception that has
* an IS-A relationship with a registered fallback's exception, then that
* fallback's alternative {@link Func} will be used to provide a result.
*
*
Example scenario: you need to fetch product data
* from a database which may potentially not be available (SQLException).
* As a fallback, you then fetch the data from a local cache that is
* guaranteed not to fail. This is a sketch of what this code may look like:
*
*
* {@code
* final Product product = new FuncWithFallback<>(
* id -> new SqlProduct().apply(id),
* new Fallback.From<>(
* SQLException.class,
* id -> new CachedProduct().apply(id)
* )
* ).apply(id);
* }
*
*
* If you register several fallback plans for exception types belonging to
* the same hierarchy, then the fallback plan whose exception type has the
* closest {@link InheritanceLevel} to the exception thrown will be used.
*
*
Example scenario: sometimes {@code SqlProduct} from
* above will throw {@link SQLRecoverableException} (a sub class of
* {@link SQLException}). In such cases you may want to simply retry the same
* {@link Func}:
*
*
* {@code
* final Product product = new FuncWithFallback<>(
* id -> new SqlProduct().apply(id),
* new IterableOf<>(
* new Fallback.From<>(
* SQLException.class,
* id -> new CachedProduct().apply(id)
* ),
* new Fallback.From<>(
* SQLRecoverableException.class,
* id -> new SqlProduct().apply(id) // run it again
* )
* )
* ).apply(id);
* }
*
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @see ScalarWithFallback
* @since 0.2
*/
public final class FuncWithFallback implements Func {
/**
* The func.
*/
private final Func func;
/**
* The fallbacks.
*/
private final Iterable> fallbacks;
/**
* Ctor.
* @param fnc The func
* @param fbks The fallbacks
*/
@SafeVarargs
public FuncWithFallback(final Func fnc, final Fallback... fbks) {
this(fnc, new IterableOf<>(fbks));
}
/**
* Ctor.
* @param fnc The func
* @param fbks The fallbacks
*/
public FuncWithFallback(
final Func fnc, final Iterable> fbks
) {
this.func = fnc;
this.fallbacks = fbks;
}
@Override
public Y apply(final X input) throws Exception {
return new ScalarWithFallback<>(
() -> this.func.apply(input),
this.fallbacks
).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/func/IoCheckedBiFunc.java 0000664 0000000 0000000 00000003751 14000546503 0024465 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.io.IOException;
import org.cactoos.BiFunc;
import org.cactoos.scalar.IoChecked;
/**
* Func that doesn't throw checked {@link Exception}, but throws
* {@link IOException} instead.
*
* There is no thread-safety guarantee.
* @param Type of input
* @param Type of input
* @param Type of output
* @since 0.13
*/
public final class IoCheckedBiFunc implements BiFunc {
/**
* Original func.
*/
private final BiFunc func;
/**
* Ctor.
* @param fnc Encapsulated func
*/
public IoCheckedBiFunc(final BiFunc fnc) {
this.func = fnc;
}
@Override
public Z apply(final X first, final Y second) throws IOException {
return new IoChecked<>(
() -> this.func.apply(first, second)
).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/func/IoCheckedFunc.java 0000664 0000000 0000000 00000003611 14000546503 0024205 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.io.IOException;
import org.cactoos.Func;
import org.cactoos.scalar.IoChecked;
/**
* Func that doesn't throw checked {@link Exception}, but throws
* {@link IOException} instead.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.4
*/
public final class IoCheckedFunc implements Func {
/**
* Original func.
*/
private final Func func;
/**
* Ctor.
* @param fnc Encapsulated func
*/
public IoCheckedFunc(final Func fnc) {
this.func = fnc;
}
@Override
public Y apply(final X input) throws IOException {
return new IoChecked<>(() -> this.func.apply(input)).value();
}
}
cactoos-0.49/src/main/java/org/cactoos/func/Repeated.java 0000664 0000000 0000000 00000004420 14000546503 0023303 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
/**
* Func that repeats its calculation a few times before
* returning the last result.
*
* @param Type of input
* @param Type of output
* @since 0.6
*/
public final class Repeated implements Func {
/**
* Original func.
*/
private final Func func;
/**
* How many times to run.
*/
private final int times;
/**
* Ctor.
*
* If {@code max} is equal or less than zero {@link #apply(Object)}
* will return an exception.
*
* @param fnc Func original
* @param max How many times
*/
public Repeated(final Func fnc, final int max) {
this.func = fnc;
this.times = max;
}
@Override
public Y apply(final X input) throws Exception {
if (this.times <= 0) {
throw new IllegalArgumentException(
"The number of repetitions must be at least 1"
);
}
Y result = null;
for (int idx = 0; idx < this.times; ++idx) {
result = this.func.apply(input);
}
return result;
}
}
cactoos-0.49/src/main/java/org/cactoos/func/Retry.java 0000664 0000000 0000000 00000010104 14000546503 0022653 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.time.Duration;
import org.cactoos.Func;
/**
* Func that will try a few times before throwing an exception.
*
* There is no thread-safety guarantee.
*
* @param Type of input
* @param Type of output
* @since 0.8
*/
public final class Retry implements Func {
/**
* Original func.
*/
private final Func func;
/**
* Exit condition.
*/
private final Func exit;
/**
* Wait between executions.
*/
private final Duration wait;
/**
* Ctor.
* @param fnc Func original
*/
public Retry(final Func fnc) {
// @checkstyle MagicNumberCheck (1 line)
this(fnc, 3);
}
/**
* Ctor.
* @param fnc Func original
* @param attempts Maximum number of attempts
*/
public Retry(final Func fnc, final int attempts) {
this(fnc, attempts, Duration.ZERO);
}
/**
* Ctor.
*
* @param fnc Func original
* @param attempts Maximum number of attempts
* @param wait The executions of the function
*/
public Retry(final Func fnc, final int attempts,
final Duration wait) {
this(fnc, attempt -> attempt >= attempts, wait);
}
/**
* Ctor.
*
* @param fnc Func original
* @param ext Exit condition, returns TRUE if there is no more reason to try
*/
public Retry(final Func fnc, final Func ext) {
this(fnc, ext, Duration.ZERO);
}
/**
* Ctor.
*
* @param fnc Func original
* @param ext Exit condition, returns TRUE if there is no more reason to try
* @param wait The executions of the function
*/
public Retry(final Func fnc, final Func ext,
final Duration wait) {
this.func = fnc;
this.exit = ext;
this.wait = wait;
}
@Override
@SuppressWarnings("PMD.AvoidCatchingGenericException")
public Y apply(final X input) throws Exception {
int attempt = 0;
Exception error = new IllegalArgumentException(
"An immediate exit, didn't have a chance to try at least once"
);
while (!this.exit.apply(attempt)) {
try {
return this.func.apply(input);
} catch (final InterruptedException ex) {
Thread.currentThread().interrupt();
error = ex;
break;
// @checkstyle IllegalCatchCheck (1 line)
} catch (final Exception ex) {
error = ex;
}
if (!this.wait.isZero() && !this.wait.isNegative()) {
try {
Thread.sleep(this.wait.toMillis());
} catch (final InterruptedException ex) {
error = ex;
break;
}
}
++attempt;
}
throw error;
}
}
cactoos-0.49/src/main/java/org/cactoos/func/SolidBiFunc.java 0000664 0000000 0000000 00000004122 14000546503 0023712 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.BiFunc;
/**
* BiFunc that is thread-safe and sticky.
*
* Objects of this class are thread safe.
*
* @param Type of first input
* @param Type of second input
* @param Type of output
* @since 0.24
*/
public final class SolidBiFunc implements BiFunc {
/**
* Original func.
*/
private final BiFunc func;
/**
* Ctor.
* @param fnc Func original
*/
public SolidBiFunc(final BiFunc fnc) {
this(fnc, Integer.MAX_VALUE);
}
/**
* Ctor.
* @param fnc Func original
* @param max Max buffer length
* @since 0.26
*/
public SolidBiFunc(final BiFunc fnc, final int max) {
this.func = new SyncBiFunc<>(new StickyBiFunc<>(fnc, max));
}
@Override
public Z apply(final X first, final Y second) throws Exception {
return this.func.apply(first, second);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/SolidFunc.java 0000664 0000000 0000000 00000003774 14000546503 0023453 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import org.cactoos.Func;
/**
* Func that is thread-safe and sticky.
*
* Objects of this class are thread safe.
*
* @param Type of input
* @param Type of output
* @since 0.24
*/
public final class SolidFunc implements Func {
/**
* Original func.
*/
private final Func func;
/**
* Ctor.
* @param fnc Original function
*/
public SolidFunc(final Func fnc) {
this(fnc, Integer.MAX_VALUE);
}
/**
* Ctor.
* @param fnc Original function
* @param max Max caching buffer length
* @since 0.26
*/
public SolidFunc(final Func fnc, final int max) {
this.func = new SyncFunc<>(new StickyFunc<>(fnc, max));
}
@Override
public Y apply(final X input) throws Exception {
return this.func.apply(input);
}
}
cactoos-0.49/src/main/java/org/cactoos/func/StickyBiFunc.java 0000664 0000000 0000000 00000005712 14000546503 0024114 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2017-2020 Yegor Bugayenko
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.cactoos.func;
import java.util.LinkedHashMap;
import java.util.Map;
import org.cactoos.BiFunc;
import org.cactoos.map.MapEntry;
import org.cactoos.scalar.Sticky;
/**
* Func that accepts two arguments and caches previously calculated values
* and doesn't recalculate again.
*
* Pay attention that this class is not thread-safe. It is highly
* recommended to always decorate it with {@link SyncBiFunc}.
*
* This {@link BiFunc} decorator technically is an in-memory
* cache.
*
* There is no thread-safety guarantee.
* @param Type of input
* @param
[](https://www.0crat.com/contrib/C63314D6Z)
[](https://www.elegantobjects.org)
[](https://www.0crat.com/p/C63314D6Z)
[](http://www.rultor.com/p/yegor256/cactoos)
[](https://www.jetbrains.com/idea/)
[](https://travis-ci.org/yegor256/cactoos)
[](https://ci.appveyor.com/project/yegor256/cactoos)
[](http://www.javadoc.io/doc/org.cactoos/cactoos)
[](http://www.0pdd.com/p?name=yegor256/cactoos)
[](https://maven-badges.herokuapp.com/maven-central/org.cactoos/cactoos)
[](https://github.com/yegor256/cactoos/blob/master/LICENSE.txt)
[](https://i.jpeek.org/org.cactoos/cactoos/)
[](https://codecov.io/github/yegor256/cactoos?branch=master)
[](https://sonarcloud.io/dashboard?id=org.cactoos%3Acactoos)
[](https://hitsofcode.com/view/github/yegor256/cactoos)
Project architect: [@victornoel](https://github.com/victornoel)
**ATTENTION**: We're still in a very early alpha version, the API
may and _will_ change frequently. Please, use it at your own risk,
until we release version 1.0. You can view our progress towards
this release [here](https://github.com/yegor256/cactoos/milestone/1).
Cactoos is a collection of object-oriented Java primitives.
**Motivation**.
We are not happy with
[JDK](https://en.wikipedia.org/wiki/Java_Development_Kit),
[Guava](https://github.com/google/guava), and
[Apache Commons](https://commons.apache.org/) because
they are procedural and not object-oriented. They do their job,
but mostly through static methods. Cactoos is suggesting
to do almost exactly the same, but through objects.
**Principles**.
These are the [design principles](https://www.elegantobjects.org#principles) behind Cactoos.
**How to use**.
The library has no dependencies. All you need is this
(get the latest version [here](https://github.com/yegor256/cactoos/releases)):
Maven:
```xml