io.qt.QFlags Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation
Show all versions of qtjambi Show documentation
QtJambi base module containing QtCore, QtGui and QtWidgets.
/****************************************************************************
**
** Copyright (C) 2009-2024 Dr. Peter Droste, Omix Visualization GmbH & Co. KG. All rights reserved.
**
** This file is part of Qt Jambi.
**
** $BEGIN_LICENSE$
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** $END_LICENSE$
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
package io.qt;
import java.util.ArrayList;
import java.util.Arrays;
import io.qt.internal.EnumUtility;
/**
*
* The QFlags class provides a type-safe way of storing OR-combinations of enum values.
*
*
* Java wrapper for Qt's class QFlags
*
*
*/
@SuppressWarnings("serial")
public abstract class QFlags implements java.io.Serializable, Cloneable {
/**
* See QFlags::QFlags(std::initializer_list<Enum>)
*/
@SafeVarargs
protected QFlags(@Nullable T @NonNull... args) {
set(args);
}
/**
* See QFlags::QFlags(QFlag)
*/
protected QFlags(int value) {
this.value = value;
}
/**
* Clones the flags
*/
@SuppressWarnings("unchecked")
public @Nullable QFlags clone() {
try {
return (QFlags) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
/**
* See QFlags::operator|(Enum) const
*/
public @StrictNonNull QFlags combined(@Nullable T flag) {
return clone().setFlag(flag, true);
}
/**
* See QFlags::operator&=(Enum)
* and QFlags::operator~()
*/
public @StrictNonNull QFlags cleared(@Nullable T flag) {
return clone().setFlag(flag, false);
}
/**
* See QFlags::operator|=(QFlags<T>)
*/
public final void set(@StrictNonNull QFlags flag) {
if(flag.getClass()==getClass())
value |= flag.value();
}
/**
*
* Overloaded constructor for
* {@link #setFlag(QtAbstractFlagEnumerator, boolean)} with
* on = true.
*
*/
public @NonNull QFlags setFlag(@Nullable T flag) {
return setFlag(flag, true);
}
/**
* See QFlags::setFlag(Enum, bool)
*/
public @NonNull QFlags setFlag(@Nullable T flag, boolean on) {
if (on) {
if (flag instanceof QtFlagEnumerator) {
value |= ((QtFlagEnumerator) flag).value();
} else if (flag instanceof QtByteFlagEnumerator) {
value |= ((QtByteFlagEnumerator) flag).value();
} else if (flag instanceof QtShortFlagEnumerator) {
value |= ((QtShortFlagEnumerator) flag).value();
} else if (flag instanceof QtLongFlagEnumerator) {
value |= ((QtLongFlagEnumerator) flag).value();
}
} else {
if (flag instanceof QtFlagEnumerator) {
value &= ~((QtFlagEnumerator) flag).value();
} else if (flag instanceof QtByteFlagEnumerator) {
value &= ~((QtByteFlagEnumerator) flag).value();
} else if (flag instanceof QtShortFlagEnumerator) {
value &= ~((QtShortFlagEnumerator) flag).value();
} else if (flag instanceof QtLongFlagEnumerator) {
value &= ~((QtLongFlagEnumerator) flag).value();
}
}
return this;
}
/**
* See QFlags::operator|=(Enum)
*/
@SafeVarargs
public final void set(@Nullable T @NonNull... ts) {
for (T flag : ts) {
setFlag(flag, true);
}
}
/**
* See QFlags::operator&=(Enum)
* and QFlags::operator~()
*/
@SafeVarargs
public final void exclude(@Nullable T @NonNull... ts) {
for (T flag : ts) {
setFlag(flag, false);
}
}
/**
* @deprecated Use {@link #testFlags(QFlags)} instead.
*/
@Deprecated(forRemoval=true)
public final boolean isSet(@StrictNonNull QFlags other) {
return testFlags(other);
}
/**
* @deprecated Use {@link #testFlags(QtAbstractFlagEnumerator...)} instead.
*/
@Deprecated(forRemoval=true)
@SafeVarargs
public final boolean isSet(@Nullable T @NonNull... flags) {
return testFlags(flags);
}
/**
* See
* QFlags::testFlag(Enum)const
*/
public final boolean testFlag(@Nullable T flag) {
if (flag instanceof QtFlagEnumerator) {
QtFlagEnumerator t = (QtFlagEnumerator) flag;
return (value & t.value()) == t.value();
} else if (flag instanceof QtByteFlagEnumerator) {
QtByteFlagEnumerator t = (QtByteFlagEnumerator) flag;
return (value & t.value()) == t.value();
} else if (flag instanceof QtShortFlagEnumerator) {
QtShortFlagEnumerator t = (QtShortFlagEnumerator) flag;
return (value & t.value()) == t.value();
} else if (flag instanceof QtLongFlagEnumerator) {
QtLongFlagEnumerator t = (QtLongFlagEnumerator) flag;
return (value & t.value()) == t.value();
}
return false;
}
/**
* See QFlags::testFlags(QFlags<T>)const
*/
@SafeVarargs
public final boolean testFlags(@Nullable T @NonNull... flags) {
QFlags f = this.clone();
f.clearAll();
f.set(flags);
return (value & f.value()) == f.value();
}
/**
* See QFlags::testFlags(QFlags<T>)const
*/
public final boolean testFlags(@StrictNonNull QFlags flags) {
if(flags.getClass()==getClass())
return (value & flags.value()) == flags.value();
return false;
}
/**
* See QFlags::testAnyFlags(QFlags<T>)const
*/
public final boolean testAnyFlags(@StrictNonNull QFlags flags) {
if(flags.getClass()==getClass())
return (value & flags.value()) != 0;
return false;
}
/**
* See QFlags::testAnyFlags(QFlags<T>)const
*/
@SafeVarargs
public final boolean testAnyFlags(@Nullable T @NonNull... flags) {
QFlags f = this.clone();
f.clearAll();
f.set(flags);
return (value & f.value()) != 0;
}
/**
* Clears the flag other.
* See QFlags::operator&=(QFlags<T>)
* and QFlags::operator~()
*/
public final void clear(@StrictNonNull QFlags other) {
if(other.getClass()==getClass())
value &= ~other.value();
}
/**
* Clears all flags in ts.
* See QFlags::operator&=(Enum)
* and QFlags::operator~()
*/
@SafeVarargs
public final void clear(@Nullable T @NonNull... ts) {
for (T flag : ts) {
setFlag(flag, false);
}
}
/**
* Clears all flags.
*/
public final void clearAll() {
value = 0;
}
/**
* Sets the value of this QFlags.
*
* @param value new value
*/
@NativeAccess
public final void setValue(int value) {
this.value = value;
}
/**
* See QFlags::toInt() const
*/
public final int toInt() {
return value;
}
/**
* Returns the value of this QFlags.
* @return value
*/
@NativeAccess
public final int value() {
return value;
}
/**
* Returns an array of flag objects represented by this QFlags.
* @return array of enum entries
*/
public @NonNull T@NonNull[] flags() {
return flags(EnumUtility.flagConstants(this));
}
/**
* Returns an unmodifiable set of flag objects represented by this QFlags.
* @return array of enum entries
*/
protected final @NonNull T@NonNull[] flags(@Nullable T @StrictNonNull[] possibleValues) {
if (possibleValues == null || possibleValues.length == 0)
return possibleValues;
java.util.List result = new ArrayList<>();
T zeroValue = null;
for (T possibleValue : possibleValues) {
boolean isNull = false;
if (possibleValue instanceof QtFlagEnumerator) {
isNull = 0 == ((QtFlagEnumerator) possibleValue).value();
} else if (possibleValue instanceof QtByteFlagEnumerator) {
isNull = 0 == ((QtByteFlagEnumerator) possibleValue).value();
} else if (possibleValue instanceof QtShortFlagEnumerator) {
isNull = 0 == ((QtShortFlagEnumerator) possibleValue).value();
} else if (possibleValue instanceof QtLongFlagEnumerator) {
isNull = 0 == ((QtLongFlagEnumerator) possibleValue).value();
}
if (isNull) {
zeroValue = possibleValue;
} else {
if (this.isSet(possibleValue)) {
result.add(possibleValue);
}
}
}
if (zeroValue != null && result.isEmpty() && value == 0) {
result.add(zeroValue);
}
return result.toArray(Arrays.copyOf(possibleValues, result.size()));
}
/**
* Returns true if the given object is instance of the same class and has the same flag value.
*/
@Override
public final boolean equals(Object object) {
return object != null && object.getClass() == getClass() && ((QFlags) object).value() == value();
}
/**
* Returns a hash code computed from the flag's class and its value.
*/
@Override
public final int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + getClass().hashCode();
result = prime * result + value();
return result;
}
/**
* Returns the string representation of the object given by QVariant(this).toString().
*/
@Override
public final @NonNull String toString() {
QtAbstractFlagEnumerator[] flags = flags();
String className = this.getClass().getName();
int idx = className.lastIndexOf('.');
if (idx > 0) {
className = className.substring(idx + 1);
}
StringBuilder result = new StringBuilder();
for (String part : className.split("\\$")) {
if (part.isEmpty()) {
result.append('$');
} else {
if (part.charAt(0) >= '0' && part.charAt(0) <= '9') {
result.append('$');
} else {
if (result.length() > 0)
result.append('.');
}
result.append(part);
}
}
result.append('(');
if (flags.length == 0 && value() != 0) {
String hexString = Integer.toHexString(value);
result.append("0x");
for (int i = hexString.length(); i < 8; ++i) {
result.append('0');
}
result.append(hexString);
} else {
int initialLength = result.length();
for (QtAbstractFlagEnumerator flag : flags) {
if (result.length() > initialLength) {
result.append('|');
}
result.append(flag.name());
}
}
result.append(')');
return result.toString();
}
private int value;
@io.qt.NativeAccess
static final class ConcreteWrapper extends QFlags implements Comparable>{
@io.qt.NativeAccess
ConcreteWrapper(int value) {
super(value);
}
public @NonNull QtFlagEnumerator @NonNull[] flags() {
return new QtFlagEnumerator[] { new QtFlagEnumerator() {
@Override
public int value() {
return ConcreteWrapper.this.value();
}
@Override
public int ordinal() {
return -1;
}
@Override
public String name() {
return "unknown";
}
@Override
public Class getDeclaringClass() {
return this.getClass();
}
} };
}
@Override
public @NonNull ConcreteWrapper clone() {
return new ConcreteWrapper(value());
}
@Override
public @NonNull ConcreteWrapper combined(@StrictNonNull QtFlagEnumerator flag) {
return new ConcreteWrapper(value() | flag.value());
}
@Override
public int compareTo(@StrictNonNull QFlags o) {
return Integer.compare(value(), o.value());
}
}
/**
* Compares two QFlags values numerically.
* The value returned is identical to what would be returned by:
*
* Integer.compare(a.value(), b.value())
*
*/
public static int compare(@StrictNonNull QFlags a, @StrictNonNull QFlags b) {
return Integer.compare(a.value(), b.value());
}
}