BaseDataTypeFactory.java
/*
** Module : BaseDataTypeFactory.java
** Abstract : Factory for BaseDataType
**
** Copyright (c) 2023-2025, Golden Code Development Corporation.
**
** -#- -I- --Date-- ----------------------------------Description-----------------------------------
** 001 RAA 20230525 Created initial version.
** AL2 20230525 Ordered types alphabetically.
** AL2 20230525 Moved to CentralLogger.
** 002 RAA 20230601 Added check for ObjectVar.
** RAA 20230615 Added possibility to instantiate with an initial value.
** 003 CA 20240331 Use logical constants for TRUE, FALSE, UNKNOWN, within internal FWD runtime, so logical
** type checks must include sub-classes, too.
** 004 CA 20241107 Added character constant support.
** 005 ICP 20250123 Added support for integer and int64 constants.
*/
/*
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU Affero General Public License as
** published by the Free Software Foundation, either version 3 of the
** License, or (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU Affero General Public License for more details.
**
** You may find a copy of the GNU Affero GPL version 3 at the following
** location: https://www.gnu.org/licenses/agpl-3.0.en.html
**
** Additional terms under GNU Affero GPL version 3 section 7:
**
** Under Section 7 of the GNU Affero GPL version 3, the following additional
** terms apply to the works covered under the License. These additional terms
** are non-permissive additional terms allowed under Section 7 of the GNU
** Affero GPL version 3 and may not be removed by you.
**
** 0. Attribution Requirement.
**
** You must preserve all legal notices or author attributions in the covered
** work or Appropriate Legal Notices displayed by works containing the covered
** work. You may not remove from the covered work any author or developer
** credit already included within the covered work.
**
** 1. No License To Use Trademarks.
**
** This license does not grant any license or rights to use the trademarks
** Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
** of Golden Code Development Corporation. You are not authorized to use the
** name Golden Code, FWD, or the names of any author or contributor, for
** publicity purposes without written authorization.
**
** 2. No Misrepresentation of Affiliation.
**
** You may not represent yourself as Golden Code Development Corporation or FWD.
**
** You may not represent yourself for publicity purposes as associated with
** Golden Code Development Corporation, FWD, or any author or contributor to
** the covered work, without written authorization.
**
** 3. No Misrepresentation of Source or Origin.
**
** You may not represent the covered work as solely your work. All modified
** versions of the covered work must be marked in a reasonable way to make it
** clear that the modified work is not originating from Golden Code Development
** Corporation or FWD. All modified versions must contain the notices of
** attribution required in this license.
*/
package com.goldencode.p2j.util;
import java.lang.reflect.InvocationTargetException;
import com.goldencode.p2j.ui.NoopComHandle;
import com.goldencode.p2j.util.logging.CentralLogger;
/**
* Class responsible with instantiating a data type.
*/
public class BaseDataTypeFactory
{
/** Logger */
private static final CentralLogger LOG = CentralLogger.get(BaseDataTypeFactory.class);
/**
* Create a new instance of the give type, if valid.
*
* @param <T>
* The given type.
* @param cls
* Instance class.
*
* @return An instance with the given type.
*/
public static <T> T instantiate(Class<T> cls)
throws InstantiationException,
IllegalAccessException,
InvocationTargetException,
NoSuchMethodException,
SecurityException
{
return instantiate(cls, null);
}
/**
* Create a new instance of the give type, if valid.
*
* @param <T>
* The given type.
* @param cls
* Instance class.
* @param newValue
* The value to be used for the instance.
*
* @return An instance with the given type.
*/
public static <T> T instantiate(Class<T> cls, BaseDataType newValue)
throws InstantiationException,
IllegalAccessException,
InvocationTargetException,
NoSuchMethodException,
SecurityException
{
if (cls == blob.class)
{
return newValue == null ? (T) new blob() : (T) new blob(newValue);
}
else if (cls == character.class || cls == character.characterConstant.class)
{
return newValue == null ? (T) new character() : (T) new character(newValue);
}
else if (cls == clob.class)
{
return newValue == null ? (T) new clob() : (T) new clob(newValue);
}
else if (cls == comhandle.class)
{
return newValue == null ? (T) new comhandle() : (T) new comhandle(newValue);
}
else if (cls == date.class)
{
return newValue == null ? (T) new date() : (T) new date(newValue);
}
else if (cls == datetime.class)
{
return newValue == null ? (T) new datetime() : (T) new datetime(newValue);
}
else if (cls == datetimetz.class)
{
return newValue == null ? (T) new datetimetz() : (T) new datetimetz(newValue);
}
else if (cls == decimal.class)
{
return newValue == null ? (T) new decimal() : (T) new decimal(newValue);
}
else if (cls == handle.class)
{
return newValue == null ? (T) new handle() : (T) new handle(newValue);
}
else if (cls == int64.class || cls == int64.int64Constant.class)
{
return newValue == null ? (T) new int64() : (T) new int64(newValue);
}
else if (cls == integer.class || cls == integer.integerConstant.class)
{
return newValue == null ? (T) new integer() : (T) new integer(newValue);
}
else if (cls == jobject.class)
{
return newValue == null ? (T) new jobject<>() : (T) new jobject<>(newValue);
}
else if (cls == logical.class || cls == logical.logicalConstant.class)
{
return newValue == null ? (T) new logical() : (T) new logical(newValue);
}
else if (cls == longchar.class)
{
return newValue == null ? (T) new longchar() : (T) new longchar(newValue);
}
else if (cls == memptr.class)
{
return newValue == null ? (T) new memptr() : (T) new memptr(newValue);
}
else if (cls == NoopComHandle.class && newValue == null)
{
return (T) new NoopComHandle();
}
else if (cls == object.class && newValue == null)
{
return (T) new object<>();
}
else if (cls == ObjectVar.class && newValue == null)
{
return (T) new ObjectVar<>();
}
else if (cls == raw.class)
{
return newValue == null ? (T) new raw() : (T) new raw(newValue);
}
else if (cls == recid.class)
{
return newValue == null ? (T) new recid() : (T) new recid(newValue);
}
else if (cls == rowid.class)
{
return newValue == null ? (T) new rowid() : (T) new rowid(newValue);
}
else if (cls == unknown.class)
{
return (T) unknown.UNKNOWN;
}
LOG.warning("Type " + cls + " instantiated via reflection, as it is not registered in BaseDataTypeFactory");
return newValue == null ? cls.getDeclaredConstructor().newInstance() :
cls.getDeclaredConstructor().newInstance(newValue);
}
}