private void addNonPreferredNameButtonActionPerformed() {
Names namesModel = (Names) this.getModel();
NonPreferredNames newNonPreferredName;
DomainEditor dialogNonPreferredNames = null;
try {
dialogNonPreferredNames =
DomainEditorFactory.getInstance()
.createDomainEditorWithParent(NonPreferredNames.class, this.getParentEditor(), false);
} catch (DomainEditorCreationException e) {
new ErrorDialog(getParentEditor(), "Error creating editor for NonPreferredNames", e)
.showDialog();
}
dialogNonPreferredNames.setNewRecord(true);
int returnStatus;
Boolean done = false;
while (!done) {
newNonPreferredName = new NonPreferredNames(namesModel);
newNonPreferredName.setNameType(namesModel.getNameType());
dialogNonPreferredNames.setModel(newNonPreferredName, null);
returnStatus = dialogNonPreferredNames.showDialog();
if (returnStatus == JOptionPane.OK_OPTION) {
namesModel.addNonPreferredName(newNonPreferredName);
nonPreferredNamesTable.getEventList().add(newNonPreferredName);
done = true;
} else if (returnStatus == StandardEditor.OK_AND_ANOTHER_OPTION) {
namesModel.addNonPreferredName(newNonPreferredName);
nonPreferredNamesTable.getEventList().add(newNonPreferredName);
} else {
done = true;
}
}
}
/** Test names? */
public void testTheNames() {
Names.getInstance()
.init(
getNameElement(
SettingsHandler.getPcgenSystemDir()
+ File.separator
+ "bio"
+ File.separator
+ "names"
+ File.separator,
"orc"),
getCharacter());
// for (Iterator iterator = Names.getInstance().getRuleList().iterator();
// iterator.hasNext();) {
// String rule = (String) iterator.next();
// System.out.println("rule = " + rule);
// }
// for (Iterator iterator = Names.getInstance().getSyllablesByName("[SYL1]").iterator();
// iterator.hasNext();) {
// String syl1 = (String) iterator.next();
// System.out.println("syl1 = " + syl1);
// }
assertTrue("I got null rules!", Names.getInstance().getRuleDefinitions() != null);
assertTrue("I didn't get any rules!", Names.getInstance().getRuleDefinitions().length > 0);
assertTrue(
"There was nothing in syl1", Names.getInstance().getSyllablesByName("[SYL1]").length > 0);
}
private static void addSetterDeclaration(
Names names, JDefinedClass paramType, JDefinedClass setterReturnType) {
JMethod method = setterReturnType.method(JMod.NONE, setterReturnType, names.getSetterName());
method.param(paramType, names.getParamName());
JDocComment javadoc = method.javadoc();
javadoc.append(names.getJavadoc());
}
/** @throws Exception */
public void testGettingNameFiles() throws Exception {
assertTrue("got null back!", Names.findAllNamesFiles() != null);
List<NameElement> nameList = Names.findAllNamesFiles();
assertTrue("got empty array back!", nameList.size() > 0);
for (int i = 0; i < nameList.size(); i++) {
final NameElement e = nameList.get(i);
System.out.println("s = " + e);
}
}
public static void addGetterSetterDeclaration(
Names names, JClass type, JDefinedClass jDefinedClass) {
addGetterDeclaration(names, type, jDefinedClass);
JMethod method = jDefinedClass.method(JMod.NONE, jDefinedClass, names.getSetterName());
method.param(type, names.getParamName());
JDocComment javadoc = method.javadoc();
javadoc.append(names.getJavadoc());
}
public static RDouble exclude(int excludeIndex, RDouble orig) {
Names names = orig.names();
if (names == null) {
return new RDoubleExclusion(excludeIndex, orig);
}
int size = orig.size();
int nsize = size - 1;
double[] content = new double[nsize];
for (int i = 0; i < excludeIndex; i++) {
content[i] = orig.getDouble(i);
}
for (int i = excludeIndex; i < nsize; i++) {
content[i] = orig.getDouble(i + 1);
}
return RDoubleFactory.getFor(content, null, names.exclude(excludeIndex));
}
private void fillMyPhoneBook(MyPhoneBook myPhoneBook, int count) {
for (int i = 0; i < count; i++) {
String name = Names.values()[i].toString();
String phone = Phones.values()[i].toString().substring(1);
myPhoneBook.addPhoneNumber(name, phone);
}
}
/** Test female name */
public void testASFemale() {
Names.getInstance()
.init(
getNameElement(
SettingsHandler.getPcgenSystemDir()
+ File.separator
+ "bio"
+ File.separator
+ "names"
+ File.separator,
"rw_Anglo_Saxon_Female"),
getCharacter());
assertTrue("got a null name!", Names.getInstance().getRandomName() != null);
assertTrue("got a zero-length name!", Names.getInstance().getRandomName().length() > 0);
System.out.println("random Anglo Saxon Female name: " + Names.getInstance().getRandomName());
}
@Override
public void visitTopLevel(JCCompilationUnit tree) {
JavaFileObject prev = log.useSource(tree.sourcefile);
boolean addEnv = false;
boolean isPkgInfo =
tree.sourcefile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE);
if (tree.pid != null) {
tree.packge = reader.enterPackage(TreeInfo.fullName(tree.pid));
if (tree.packageAnnotations.nonEmpty() || pkginfoOpt == PkgInfo.ALWAYS) {
if (isPkgInfo) {
addEnv = true;
} else {
log.error(tree.packageAnnotations.head.pos(), "pkg.annotations.sb.in.package-info.java");
}
}
} else {
tree.packge = syms.unnamedPackage;
}
tree.packge.complete(); // Find all classes in package.
Env<AttrContext> topEnv = topLevelEnv(tree);
// Save environment of package-info.java file.
if (isPkgInfo) {
Env<AttrContext> env0 = typeEnvs.get(tree.packge);
if (env0 == null) {
typeEnvs.put(tree.packge, topEnv);
} else {
JCCompilationUnit tree0 = env0.toplevel;
if (!fileManager.isSameFile(tree.sourcefile, tree0.sourcefile)) {
log.warning(
tree.pid != null ? tree.pid.pos() : null, "pkg-info.already.seen", tree.packge);
if (addEnv
|| (tree0.packageAnnotations.isEmpty()
&& tree.docComments != null
&& tree.docComments.get(tree) != null)) {
typeEnvs.put(tree.packge, topEnv);
}
}
}
for (Symbol q = tree.packge; q != null && q.kind == PCK; q = q.owner) q.flags_field |= EXISTS;
Name name = names.package_info;
ClassSymbol c = reader.enterClass(name, tree.packge);
c.flatname = names.fromString(tree.packge + "." + name);
c.sourcefile = tree.sourcefile;
c.completer = null;
c.members_field = new Scope(c);
tree.packge.package_info = c;
}
classEnter(tree.defs, topEnv);
if (addEnv) {
todo.append(topEnv);
}
log.useSource(prev);
result = null;
}
private void addNote(String whereString) {
Names namesModel = (Names) super.getModel();
NameContactNotes newNote;
DomainEditor dialog = null;
try {
dialog =
DomainEditorFactory.getInstance()
.createDomainEditorWithParent(NameContactNotes.class, this.getParentEditor(), false);
} catch (DomainEditorCreationException e) {
new ErrorDialog(getParentEditor(), "Error creating editor for NameContactNotes", e)
.showDialog();
}
dialog.setNewRecord(true);
Boolean done = false;
int sequenceNumber = 0;
Boolean first = true;
int returnStatus;
while (!done) {
newNote = new NameContactNotes(namesModel);
if (first) {
sequenceNumber =
SequencedObjectsUtils.determineSequenceOfNewItem(whereString, nameContactNotesTable);
first = false;
} else {
sequenceNumber++;
}
newNote.setSequenceNumber(sequenceNumber);
dialog.setModel(newNote, null);
returnStatus = dialog.showDialog();
if (returnStatus == javax.swing.JOptionPane.OK_OPTION) {
namesModel.addNameContactNote(newNote);
nameContactNotesTable.getEventList().add(newNote);
done = true;
} else if (returnStatus == StandardEditor.OK_AND_ANOTHER_OPTION) {
namesModel.addNameContactNote(newNote);
nameContactNotesTable.getEventList().add(newNote);
} else {
done = true;
}
}
dialog.setNewRecord(false);
}
private Names createPartitionNames(Mfs mfs) throws Exception {
// try creating a proper MFS app partition name like "MFS application region 3"
List<PartitionEntry> partitions = (mfs.getMfs() == null) ? null : mfs.getMfs().getPartitions();
if ((partitions == null) || partitions.isEmpty())
throw new Exception("No MFS partitions - MFS has not been initialized");
int mediaPartitionIdx = 1;
for (PartitionEntry pe : partitions) {
if (pe == null) continue;
String name = pe.getName();
if (name == null) continue;
Matcher m = MEDIA_PARTITION_NAME.matcher(name);
if (m.matches()) mediaPartitionIdx = Integer.parseInt(m.group(1));
}
Names names = new Names();
names.descriptor = APP_PARTITION_NAME_PREFIX + ' ' + (++mediaPartitionIdx);
names.data = DATA_PARTITION_NAME_PREFIX + ' ' + mediaPartitionIdx;
return names;
}
public Method lookupJavaMethod(
IEvaluator<Result<IValue>> eval,
FunctionDeclaration func,
Environment env,
boolean hasReflectiveAccess) {
if (!func.isAbstract()) {
throw new NonAbstractJavaFunction(func);
}
String className = getClassName(func);
String name = Names.name(func.getSignature().getName());
if (className.length() == 0) { // TODO: Can this ever be thrown since the Class instance has
// already been identified via the javaClass tag.
throw new MissingTag(JAVA_CLASS_TAG, func);
}
for (ClassLoader loader : loaders) {
try {
Class<?> clazz = loader.loadClass(className);
Parameters parameters = func.getSignature().getParameters();
Class<?>[] javaTypes = getJavaTypes(parameters, env, hasReflectiveAccess);
try {
Method m;
if (javaTypes.length > 0) { // non-void
m = clazz.getMethod(name, javaTypes);
} else {
m = clazz.getMethod(name);
}
return m;
} catch (SecurityException e) {
throw RuntimeExceptionFactory.permissionDenied(
vf.string(e.getMessage()), eval.getCurrentAST(), eval.getStackTrace());
} catch (NoSuchMethodException e) {
throw new UndeclaredJavaMethod(e.getMessage(), func);
}
} catch (ClassNotFoundException e) {
continue;
}
}
throw new UndeclaredJavaMethod(className + "." + name, func);
}
/**
* Sets the model for this editor.
*
* @param model the model to be used
*/
public final void setModel(final DomainObject model, InfiniteProgressPanel progressPanel) {
super.setModel(model, progressPanel);
Names namesModel = (Names) model;
resourcesTable.updateCollection(namesModel.getResources());
accessionsTable.updateCollection(namesModel.getAccessions());
digitalObjectsTable.updateCollection(namesModel.getDigitalObjects());
nameContactNotesTable.updateCollection(namesModel.getRelatedCollection(NameContactNotes.class));
nonPreferredNamesTable.updateCollection(
namesModel.getRelatedCollection(NonPreferredNames.class));
setPluginModel(); // update any plugins with this new domain object
}
protected StringFieldMapper(
Names names,
float boost,
FieldType fieldType,
FieldType defaultFieldType,
Boolean docValues,
String nullValue,
NamedAnalyzer indexAnalyzer,
NamedAnalyzer searchAnalyzer,
NamedAnalyzer searchQuotedAnalyzer,
int positionOffsetGap,
int ignoreAbove,
SimilarityProvider similarity,
Loading normsLoading,
@Nullable Settings fieldDataSettings,
Settings indexSettings,
MultiFields multiFields,
CopyTo copyTo) {
super(
names,
boost,
fieldType,
docValues,
indexAnalyzer,
searchAnalyzer,
similarity,
normsLoading,
fieldDataSettings,
indexSettings,
multiFields,
copyTo);
if (fieldType.tokenized() && fieldType.indexOptions() != IndexOptions.NONE && hasDocValues()) {
throw new MapperParsingException(
"Field [" + names.fullName() + "] cannot be analyzed and have doc values");
}
this.defaultFieldType = defaultFieldType;
this.nullValue = nullValue;
this.positionOffsetGap = positionOffsetGap;
this.searchQuotedAnalyzer =
searchQuotedAnalyzer != null ? searchQuotedAnalyzer : this.searchAnalyzer;
this.ignoreAbove = ignoreAbove;
}
private String getClassName(FunctionDeclaration declaration) {
Tags tags = declaration.getTags();
if (tags.hasTags()) {
for (Tag tag : tags.getTags()) {
if (Names.name(tag.getName()).equals(JAVA_CLASS_TAG)) {
if (tag.hasContents()) {
String contents = ((TagString.Lexical) tag.getContents()).getString();
if (contents.length() > 2 && contents.startsWith("{")) {
contents = contents.substring(1, contents.length() - 1);
}
return contents;
}
}
}
}
return "";
}
public static Type typeOf(
List<TypeArg> args, Environment env, boolean instantiateTypeParameters) {
Type[] fieldTypes = new Type[args.size()];
String[] fieldLabels = new String[args.size()];
int i = 0;
boolean allLabeled = true;
boolean someLabeled = false;
for (TypeArg arg : args) {
fieldTypes[i] = arg.getType().typeOf(env, instantiateTypeParameters, null);
if (arg.isNamed()) {
fieldLabels[i] = Names.name(arg.getName());
someLabeled = true;
} else {
fieldLabels[i] = null;
allLabeled = false;
}
i++;
}
if (someLabeled && !allLabeled) {
// TODO: this ast is not the root of the cause
throw new PartiallyLabeledFields(args.get(0));
}
if (!allLabeled) {
return TF.tupleType(fieldTypes);
}
for (int j = 0; j < fieldLabels.length - 1; j++) {
for (int k = j + 1; k < fieldLabels.length; k++) {
if (fieldLabels[j].equals(fieldLabels[k])) {
throw new RedeclaredField(fieldLabels[j], args.get(k));
}
}
}
return TF.tupleType(fieldTypes, fieldLabels);
}
protected Enter(Context context) {
context.put(enterKey, this);
log = Log.instance(context);
reader = ClassReader.instance(context);
make = TreeMaker.instance(context);
syms = Symtab.instance(context);
chk = Check.instance(context);
memberEnter = MemberEnter.instance(context);
types = Types.instance(context);
annotate = Annotate.instance(context);
lint = Lint.instance(context);
names = Names.instance(context);
predefClassDef =
make.ClassDef(make.Modifiers(PUBLIC), syms.predefClass.name, null, null, null, null);
predefClassDef.sym = syms.predefClass;
todo = Todo.instance(context);
fileManager = context.get(JavaFileManager.class);
Options options = Options.instance(context);
pkginfoOpt = PkgInfo.get(options);
}
public FunctionRot13(Solver solver) {
super(solver);
Names.add(new LocalNames("Rot13", "en"));
}
public Person() {
citizen = Math.random() <= .7;
name = Names.GenerateName();
}
public static void addGetterDeclaration(Names names, Class<?> type, JDefinedClass jDefinedClass) {
JMethod method = jDefinedClass.method(JMod.NONE, type, names.getGetterName());
JDocComment javadoc = method.javadoc();
javadoc.append(names.getJavadoc());
}
private String getHandlerConfigFileName(String fullName) {
String name = Names.stripQualifier(fullName);
return name + "_handler.xml";
}
/** Convert contents to name. */
public Name toName(Names names) {
return names.fromUtf(elems, 0, length);
}
protected void log(String msg) {
if (options.verbose) {
System.out.println("[" + Names.stripQualifier(this.getClass().getName()) + ": " + msg + "]");
}
}
public interface RDouble extends RNumber {
String TYPE_STRING = "double";
long NA_LONGBITS = 0x7ff00000000007a2L; // R's NA is a special instance of IEEE's NaN
int NA_LOWBITS = (int) NA_LONGBITS;
double NA = Double.longBitsToDouble(NA_LONGBITS);
double NaN = Double.NaN;
double EPSILON = Math.pow(2.0, -52.0);
double NEG_INF = Double.NEGATIVE_INFINITY;
double POS_INF = Double.POSITIVE_INFINITY;
DoubleImpl EMPTY = (DoubleImpl) RArrayUtils.markShared(RDoubleFactory.getUninitializedArray(0));
ScalarDoubleImpl BOXED_ZERO =
(ScalarDoubleImpl) RArrayUtils.markShared(RDoubleFactory.getScalar(0));
ScalarDoubleImpl BOXED_NA =
(ScalarDoubleImpl) RArrayUtils.markShared(RDoubleFactory.getScalar(NA));
ScalarDoubleImpl BOXED_NEG_INF =
(ScalarDoubleImpl) RArrayUtils.markShared(RDoubleFactory.getScalar(Double.NEGATIVE_INFINITY));
ScalarDoubleImpl BOXED_POS_INF =
(ScalarDoubleImpl) RArrayUtils.markShared(RDoubleFactory.getScalar(Double.POSITIVE_INFINITY));
DoubleImpl EMPTY_NAMED_NA =
(DoubleImpl)
RArrayUtils.markShared(
RDoubleFactory.getFor(
new double[] {}, null, Names.create(new RSymbol[] {RSymbol.NA_SYMBOL})));
DoubleImpl NA_NAMED_NA =
(DoubleImpl)
RArrayUtils.markShared(
RDoubleFactory.getFor(
new double[] {NA}, null, Names.create(new RSymbol[] {RSymbol.NA_SYMBOL})));
RDouble set(int i, double val);
double getDouble(int i);
RDouble materialize();
double[] getContent();
public class RDoubleUtils {
private static final boolean ARITH_NA_CHECKS = false;
// should have explicit checks with floating point arithmetics to avoid NAs turning into NaNs?
// NOTE: GNU-R does not have these checks
public static boolean isNA(double d) {
return ((int) Double.doubleToRawLongBits(d)) == NA_LOWBITS;
}
public static boolean arithIsNA(double d) {
return ARITH_NA_CHECKS ? isNA(d) : false;
}
public static boolean fitsRInt(double d) {
return d >= Integer.MIN_VALUE && d <= Integer.MAX_VALUE;
}
public static boolean isNAorNaN(double d) {
return Double.isNaN(d);
}
public static boolean isFinite(double d) {
return !isNAorNaN(d) && !Double.isInfinite(d);
}
public static RInt double2int(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
int[] content = new int[size];
for (int i = 0; i < size; i++) {
double d = value.getDouble(i);
content[i] = Convert.double2int(d, warn);
}
return RInt.RIntFactory.getFor(content, value.dimensions(), value.names());
}
public static RRaw doubleToRaw(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
byte[] content = new byte[size];
for (int i = 0; i < size; i++) {
double dval = value.getDouble(i);
content[i] = Convert.double2raw(dval, warn);
}
return RRaw.RRawFactory.getFor(content, value.dimensions(), value.names());
}
public static double[] copyAsDoubleArray(RDouble d) {
int size = d.size();
if (size == 1) {
return new double[] {d.getDouble(0)};
} else {
double[] res = new double[size];
if (d instanceof DoubleImpl) {
System.arraycopy(((DoubleImpl) d).getContent(), 0, res, 0, size);
} else {
for (int i = 0; i < size; i++) {
res[i] = d.getDouble(i);
}
}
return res;
}
}
public static boolean hasNAorNaN(RDouble d) {
int size = d.size();
for (int i = 0; i < size; i++) {
if (isNAorNaN(d.getDouble(i))) {
return true;
}
}
return false;
}
public static RDouble convertNAandNaNtoZero(RDouble d) {
if (d instanceof ScalarDoubleImpl) {
ScalarDoubleImpl sd = (ScalarDoubleImpl) d;
if (sd.isNAorNaN()) {
return BOXED_ZERO;
} else {
return sd;
}
} else {
RDouble res = d.materialize();
double[] content = res.getContent();
for (int i = 0; i < content.length; i++) {
if (isNAorNaN(content[i])) {
content[i] = 0;
}
}
return res;
}
}
}
public class RDoubleFactory {
public static ScalarDoubleImpl getScalar(double value) {
return new ScalarDoubleImpl(value);
}
public static RDouble getScalar(
double value, int[] dimensions, Names names, Attributes attributes) {
if (dimensions == null && names == null && attributes == null) {
return new ScalarDoubleImpl(value);
} else {
return getFor(new double[] {value}, dimensions, names, attributes);
}
}
public static RDouble getArray(double... values) {
if (values.length == 1) {
return new ScalarDoubleImpl(values[0]);
}
return new DoubleImpl(values);
}
public static RDouble getArray(double[] values, int[] dimensions) {
if (dimensions == null && values.length == 1) {
return new ScalarDoubleImpl(values[0]);
}
return new DoubleImpl(values, dimensions, null);
}
public static RDouble getUninitializedArray(int size) {
if (size == 1) {
return new ScalarDoubleImpl(0);
}
return new DoubleImpl(size);
}
public static RDouble getUninitializedNonScalarArray(int size) {
return new DoubleImpl(size);
}
public static RDouble getUninitializedArray(
int size, int[] dimensions, Names names, Attributes attributes) {
if (size == 1 && dimensions == null && names == null && attributes == null) {
return new ScalarDoubleImpl(0);
}
return new DoubleImpl(new double[size], dimensions, names, attributes, false);
}
public static RDouble getNAArray(int size) {
return getNAArray(size, null);
}
public static RDouble getNAArray(int size, int[] dimensions) {
if (size == 1 && dimensions == null) {
return BOXED_NA;
}
double[] content = new double[size];
Arrays.fill(content, NA);
return new DoubleImpl(content, dimensions, null, null, false);
}
public static DoubleImpl getMatrixFor(double[] values, int m, int n) {
return new DoubleImpl(values, new int[] {m, n}, null, null, false);
}
public static RDouble copy(RDouble d) {
if (d.size() == 1 && d.dimensions() == null && d.names() == null && d.attributes() == null) {
return new ScalarDoubleImpl(d.getDouble(0));
}
return new DoubleImpl(d, false);
}
public static RDouble strip(RDouble v) {
if (v.size() == 1) {
return new ScalarDoubleImpl(v.getDouble(0));
}
return new DoubleImpl(v, true);
}
public static RDouble stripKeepNames(RDouble v) {
Names names = v.names();
if (v.size() == 1 && names == null) {
return new ScalarDoubleImpl(v.getDouble(0));
}
return new DoubleImpl(v, null, names, null);
}
public static RDouble getFor(double[] values) { // re-uses values!
return getFor(values, null, null);
}
public static RDouble getFor(
double[] values, int[] dimensions, Names names) { // re-uses values!
if (values.length == 1 && dimensions == null && names == null) {
return new ScalarDoubleImpl(values[0]);
}
return new DoubleImpl(values, dimensions, names, null, false);
}
public static RDouble getFor(
double[] values, int[] dimensions, Names names, Attributes attributes) { // re-uses values!
if (values.length == 1 && dimensions == null && names == null && attributes == null) {
return new ScalarDoubleImpl(values[0]);
}
return new DoubleImpl(values, dimensions, names, attributes, false);
}
public static RDouble getEmpty(boolean named) {
return named ? EMPTY_NAMED_NA : EMPTY;
}
public static RDouble getNA(boolean named) {
return named ? NA_NAMED_NA : BOXED_NA;
}
public static RDouble exclude(int excludeIndex, RDouble orig) {
Names names = orig.names();
if (names == null) {
return new RDoubleExclusion(excludeIndex, orig);
}
int size = orig.size();
int nsize = size - 1;
double[] content = new double[nsize];
for (int i = 0; i < excludeIndex; i++) {
content[i] = orig.getDouble(i);
}
for (int i = excludeIndex; i < nsize; i++) {
content[i] = orig.getDouble(i + 1);
}
return RDoubleFactory.getFor(content, null, names.exclude(excludeIndex));
}
public static RDouble subset(RDouble value, RInt index) {
return new RDoubleSubset(value, index);
}
}
public static class RStringView extends View.RStringProxy<RDouble> implements RString {
public RStringView(RDouble orig) {
super(orig);
}
@Override
public RComplex asComplex() {
return orig.asComplex();
}
@Override
public RDouble asDouble() {
return orig;
}
@Override
public RInt asInt() {
return orig.asInt();
}
@Override
public RRaw asRaw() {
return orig.asRaw();
}
@Override
public RComplex asComplex(ConversionStatus warn) {
return orig.asComplex();
}
@Override
public RDouble asDouble(ConversionStatus warn) {
return orig;
}
@Override
public RInt asInt(ConversionStatus warn) {
return orig.asInt(warn);
}
@Override
public RRaw asRaw(ConversionStatus warn) {
return orig.asRaw(warn);
}
@Override
public String getString(int i) {
return Convert.double2string(orig.getDouble(i));
}
}
public static class RComplexView extends View.RComplexProxy<RDouble> implements RComplex {
public RComplexView(RDouble orig) {
super(orig);
}
@Override
public RDouble asDouble() {
return orig;
}
@Override
public RInt asInt() {
return orig.asInt();
}
@Override
public RLogical asLogical() {
return orig.asLogical();
}
@Override
public RRaw asRaw() {
return orig.asRaw();
}
@Override
public RDouble asDouble(ConversionStatus warn) {
return orig;
}
@Override
public RInt asInt(ConversionStatus warn) {
return orig.asInt(warn);
}
@Override
public RLogical asLogical(ConversionStatus warn) {
return orig.asLogical();
}
@Override
public RRaw asRaw(ConversionStatus warn) {
return orig.asRaw(warn);
}
@Override
public double getReal(int i) {
double d = orig.getDouble(i);
if (RDoubleUtils.isNAorNaN(d)) {
return RDouble.NA;
} else {
return d;
}
}
@Override
public double getImag(int i) {
double d = orig.getDouble(i);
if (RDoubleUtils.isNAorNaN(d)) {
return RDouble.NA;
} else {
return 0;
}
}
}
public static class RIntView extends View.RIntProxy<RDouble> implements RInt {
public RIntView(RDouble orig) {
super(orig);
}
@Override
public int getInt(int i) {
return Convert.double2int(orig.getDouble(i));
}
}
public static class RLogicalView extends View.RLogicalProxy<RDouble> implements RLogical {
public RLogicalView(RDouble orig) {
super(orig);
}
@Override
public int getLogical(int i) {
return Convert.double2logical(orig.getDouble(i));
}
}
public static class RRawView extends View.RRawProxy<RDouble>
implements RRaw { // FIXME: remove this? it breaks warnings
public RRawView(RDouble orig) {
super(orig);
}
@Override
public byte getRaw(int i) {
return Convert.double2raw(orig.getDouble(i));
}
}
public static class RDoubleExclusion extends View.RDoubleView implements RDouble {
final RDouble orig;
final int excludeIndex;
final int size;
public RDoubleExclusion(int excludeIndex, RDouble orig) {
this.orig = orig;
this.excludeIndex = excludeIndex;
this.size = orig.size() - 1;
}
@Override
public int size() {
return size;
}
@Override
public double getDouble(int i) {
assert Utils.check(i < size, "bounds check");
assert Utils.check(i >= 0, "bounds check");
if (i < excludeIndex) {
return orig.getDouble(i);
} else {
return orig.getDouble(i + 1);
}
}
@Override
public boolean isSharedReal() {
return orig.isShared();
}
@Override
public void ref() {
orig.ref();
}
@Override
public boolean dependsOn(RAny value) {
return orig.dependsOn(value);
}
}
// indexes must all be positive
// but can be out of bounds ==> NA's are returned in that case
public static class RDoubleSubset extends View.RDoubleView implements RDouble {
final RDouble value;
final int vsize;
final RInt index;
final int isize;
public RDoubleSubset(RDouble value, RInt index) {
this.value = value;
this.index = index;
this.isize = index.size();
this.vsize = value.size();
}
@Override
public int size() {
return isize;
}
@Override
public double getDouble(int i) {
int j = index.getInt(i);
assert Utils.check(j > 0);
if (j > vsize) {
return RDouble.NA;
} else {
return value.getDouble(j - 1);
}
}
@Override
public boolean isSharedReal() {
return value.isShared() || index.isShared();
}
@Override
public void ref() {
value.ref();
index.ref();
}
@Override
public boolean dependsOn(RAny v) {
return value.dependsOn(v) || index.dependsOn(v);
}
}
}
private Names lookupName(NamesDAO namesDao, NameComplexType nameFromImport)
throws IllegalAccessException, InvocationTargetException, UnknownLookupListException,
PersistenceException, NoSuchAlgorithmException, UnsupportedEncodingException {
Names name = new Names();
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_NAME_TYPE, nameFromImport.getNameType());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_SORT_NAME, nameFromImport.getSortName());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_NAME_RULE, nameFromImport.getNameRule());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_NUMBER, nameFromImport.getNumber());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_QUALIFIER, nameFromImport.getQualifier());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_DESCRIPTION_TYPE, nameFromImport.getDescriptionType());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_DESCRIPTION_NOTE, nameFromImport.getDescriptionNote());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_CITATION, nameFromImport.getCitation());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_SALUTATION, nameFromImport.getSalutation());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_ADDRESS_1, nameFromImport.getContactAddress1());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_ADDRESS_2, nameFromImport.getContactAddress2());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_CONTACT_CITY, nameFromImport.getContactCity());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_REGION, nameFromImport.getContactRegion());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_COUNTRY, nameFromImport.getContactCountry());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_MAIL_CODE, nameFromImport.getContactMailCode());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_PHONE, nameFromImport.getContactPhone());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_CONTACT_FAX, nameFromImport.getContactFax());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CONTACT_EMAIL, nameFromImport.getContactEmail());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_CONTACT_NAME, nameFromImport.getContactName());
ImportUtils.nullSafeSet(name, Names.PROPERTYNAME_FAMILY_NAME, nameFromImport.getFamilyName());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_FAMILY_NAME_PREFIX, nameFromImport.getFamilyNamePrefix());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_CORPORATE_PRIMARY_NAME, nameFromImport.getCorporatePrimaryName());
ImportUtils.nullSafeSet(
name,
Names.PROPERTYNAME_CORPORATE_SUBORDINATE_1,
nameFromImport.getCorporateSubordinate1());
ImportUtils.nullSafeSet(
name,
Names.PROPERTYNAME_CORPORATE_SUBORDINATE_2,
nameFromImport.getCorporateSubordinate2());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_PRIMARY_NAME, nameFromImport.getPersonalPrimaryName());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_REST_OF_NAME, nameFromImport.getPersonalRestOfName());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_PREFIX, nameFromImport.getPersonalPrefix());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_SUFFIX, nameFromImport.getPersonalSuffix());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_FULLER_FORM, nameFromImport.getPersonalFullerForm());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_TITLE, nameFromImport.getPersonalTitle());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_DATES, nameFromImport.getPersonalDates());
ImportUtils.nullSafeSet(
name, Names.PROPERTYNAME_PERSONAL_DIRECT_ORDER, nameFromImport.isPersonalDirectOrder());
if (nameFromImport.getNameSource() == null) {
name.setNameSource("ingest");
} else {
name.setNameSource(nameFromImport.getNameSource());
}
if (name.getSortName() == null || name.getSortName().length() == 0) {
name.createSortName();
// check to see if sort name is still empty. If so, set it to " " so that
// this record can be inserted into an Oracle DB without throwing an error
if (name.getSortName().length() == 0) {
name.setSortName(" ");
}
}
NameUtils.setMd5Hash(name);
return namesDao.lookupName(name, true);
}
public FunctionAlphaPos(Solver solver) {
super(solver);
Names.add(new LocalNames("AlphaPos", "en"));
Names.add(new LocalNames("AP", "en"));
}
@SuppressWarnings("unchecked")
public <IFD extends IndexFieldData<?>> IFD getForField(MappedFieldType fieldType) {
final Names fieldNames = fieldType.names();
final FieldDataType type = fieldType.fieldDataType();
if (type == null) {
throw new IllegalArgumentException(
"found no fielddata type for field [" + fieldNames.fullName() + "]");
}
final boolean docValues = fieldType.hasDocValues();
IndexFieldData.Builder builder = null;
String format = type.getFormat(indexSettings);
if (format != null && FieldDataType.DOC_VALUES_FORMAT_VALUE.equals(format) && !docValues) {
logger.warn(
"field ["
+ fieldNames.fullName()
+ "] has no doc values, will use default field data format");
format = null;
}
if (format != null) {
builder = buildersByTypeAndFormat.get(Tuple.tuple(type.getType(), format));
if (builder == null) {
logger.warn(
"failed to find format ["
+ format
+ "] for field ["
+ fieldNames.fullName()
+ "], will use default");
}
}
if (builder == null && docValues) {
builder = docValuesBuildersByType.get(type.getType());
}
if (builder == null) {
builder = buildersByType.get(type.getType());
}
if (builder == null) {
throw new IllegalArgumentException(
"failed to find field data builder for field "
+ fieldNames.fullName()
+ ", and type "
+ type.getType());
}
IndexFieldDataCache cache;
synchronized (this) {
cache = fieldDataCaches.get(fieldNames.indexName());
if (cache == null) {
// we default to node level cache, which in turn defaults to be unbounded
// this means changing the node level settings is simple, just set the bounds there
String cacheType =
type.getSettings()
.get("cache", indexSettings.get(FIELDDATA_CACHE_KEY, FIELDDATA_CACHE_VALUE_NODE));
if (FIELDDATA_CACHE_VALUE_NODE.equals(cacheType)) {
cache = indicesFieldDataCache.buildIndexFieldDataCache(listener, index, fieldNames, type);
} else if ("none".equals(cacheType)) {
cache = new IndexFieldDataCache.None();
} else {
throw new IllegalArgumentException(
"cache type not supported ["
+ cacheType
+ "] for field ["
+ fieldNames.fullName()
+ "]");
}
fieldDataCaches.put(fieldNames.indexName(), cache);
}
}
return (IFD)
builder.build(index, indexSettings, fieldType, cache, circuitBreakerService, mapperService);
}
