Ignore:
Timestamp:
07/10/13 22:41:02 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGTS:

  • complete events implementation
  • add CLI in Java Framsticks server
  • add automatic registration for events in GUI
  • improve objects fetching (object are never overwritten with new instances)
  • properly react for ListChange? events
  • add ListPanel? with table view
    • columns to be shown may be statically specified in configuration
    • currently modyfying data through tables is not available
  • improve maven configuration
    • configuration file may be specified without touching pom.xml

CHANGELOG:
Extract constants from Flags into ParamFlags? and SetStateFlags?.

Extract flags I/O to FlagsUtils? class.

Configured maven to exec given resource configuration.

For example:
mvn exec:exec -Dframsticks.config=/configs/managed-console.xml

Cleanup pom.xml

Rename ObjectTree? to LocalTree? (also make LocalTree? and RemoteTree? final).

Minor change.

Add maximum number of columns in ListPanelProvider?.

Improve ColumnsConfig? interpretation.

Automatically fill FramsClass?.name if trying to construct empty.

Improve identitifer case mangling in XmlLoader?.

Introduce configurable ColumnsConfig?.

Draft working version of ListPanel?.

Table is being shown (although empty).

More improvements to table building.

Move some functionality from Frame to TreeModel?.

Move tree classes in gui to separate package.

Remove old table related classes.

Add draft implementation of TableModel?.

Redirect ParamBuilder?.forAccess to AccessInterface?.

Optimize ParamBuilder?.forAccess()

Do not clear list when loading.

Do not load fetched values directly.

Implement different AccessInterface? copying policy.

Optimize fetching values routine.

Remove Mode enum (work out get semantics).

Some improvements to ListChange? handling.

Improve UniqueListAccess?.

Add reaction for ListChanges? in the TreeNode?.

EventListeners? are being added in the TreeNode?.

Listeners for ListParams? are now very naive (they download
whole list).

Automatially register on events in GUI.

Events are working in RemoteTree? and Server.

Move listeners to the ClientSideManagedConnection?.

Remove old classes responsible for event subscriptions.

Improve event reading.

Improve events handling at server side.

Add register attribute in FramsClassAnnotation?
to automatically also register other classes.

Registering events works.

Setup for remote listeners registration.

More improvements.

Minor changes.

Add rootTree to the ClientAtServer?.

Moving CLI to the ClientAtServer?.

Fix bug: use Void.TYPE instead of Void.class

More development around CLI.

  • Improve Path resolving.

Add synthetic root to ObjectTree?.

It is needed to allow sybling for the original root
that would containg CLI.

Some work with registering events in RemoteTree?.

Draft implementation of listener registering in RemoteTree?.

Support events registration in the ObjectTree?.

Add events support to ReflectionAccess?.

EventParam? is recognized by ParamCandidate?.

Prepare interface for Events across project.

Add EventListener? and API for listeners in Tree.

Location:
java/main/src/main/java/com/framsticks/params
Files:
3 added
1 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • java/main/src/main/java/com/framsticks/params/AccessInterface.java

    r98 r99  
    22
    33
     4import com.framsticks.params.types.EventParam;
    45import com.framsticks.params.types.ProcedureParam;
    56
    … …  
    3940        <T> int set(ValueParam param, T value);
    4041
     42        void reg(EventParam param, EventListener<?> listener);
     43
     44        void regRemove(EventParam param, EventListener<?> listener);
     45
    4146        void setDefault(boolean numericOnly);
    4247
    … …  
    5055
    5156        void setMax(int i);
    52 
    53         void copyFrom(AccessInterface src);
    5457
    5558        void save(SinkInterface sink);
    … …  
    8083        CompositeParam getCompositeParam(int number);
    8184
     85        ParamBuilder buildParam(ParamBuilder builder);
     86
    8287
    8388}

  • java/main/src/main/java/com/framsticks/params/ArrayListAccess.java

    r98 r99  
    11package com.framsticks.params;
    22
     3import com.framsticks.params.types.ArrayListParam;
    34import com.framsticks.util.UnimplementedException;
    45import com.framsticks.util.lang.Numbers;
    … …  
    1516
    1617        List<Object> list;
     18
    1719
    1820        public ArrayListAccess(AccessInterface elementAccess) {
    … …  
    3537                        return null;
    3638                }
    37                 return Param.build().id(Integer.toString(i)).forAccess(elementAccess).finish(CompositeParam.class);
     39                return paramBuilder.id(Integer.toString(i)).finish(CompositeParam.class);
    3840        }
    3941
    … …  
    109111        }
    110112
    111         @Override
    112         public String computeIdentifierFor(Object selected) {
    113                 return Integer.toString(list.size());
    114         }
    115113
    116114        @Override
    … …  
    131129                                        @Override
    132130                                        public Param next() {
    133                                                 Param param = Param.build().id(Integer.toString(internal.nextIndex())).forAccess(elementAccess).finish();
     131                                                Param param = paramBuilder.id(Integer.toString(internal.nextIndex())).finish(CompositeParam.class);
    134132                                                internal.next();
    135133                                                return param;
    … …  
    156154        }
    157155
     156        @Override
     157        public ParamBuilder buildParam(ParamBuilder builder) {
     158                return builder.name(containedTypeName + " list").type(ArrayListParam.class).containedTypeName(containedTypeName);
     159        }
    158160
    159161}

  • java/main/src/main/java/com/framsticks/params/FramsClass.java

    r98 r99  
    55import com.framsticks.util.FramsticksException;
    66import com.framsticks.util.lang.Containers;
     7import com.framsticks.util.lang.Strings;
    78// import com.framsticks.util.FramsticksException;
    89
    … …  
    6061
    6162                this.id = builder.getId();
    62                 this.name = builder.getName();
     63                this.name = Strings.toStringEmptyProof(builder.getName(), this.id);
    6364                this.description = builder.getDescription();
    6465                this.groups = Containers.build(builder.groupBuilders);

  • java/main/src/main/java/com/framsticks/params/FramsClassBuilder.java

    r98 r99  
    4040
    4141        public static ParamBuilder induceParamType(ParamBuilder builder, Type type) {
     42                // if (type.equals(Void.TYPE)) {
     43                //      throw new ConstructionException().msg("void is not a valid type");
     44                // }
    4245
    4346                if (type instanceof ParameterizedType) {
    … …  
    4750                        //TODO make implementation here
    4851                        boolean map = false;
     52                        StringBuilder b = new StringBuilder();
    4953                        if (rawType.equals(Map.class)) {
    5054                                containedType = p.getActualTypeArguments()[1];
    5155                                map = true;
     56                                b.append("l");
    5257                        } else if (rawType.equals(List.class)) {
    5358                                containedType = p.getActualTypeArguments()[0];
     59                                b.append("l");
     60                        } else if (rawType.equals(EventListener.class)) {
     61                                containedType = p.getActualTypeArguments()[0];
     62                                b.append("e");
    5463                        }
    5564                        if (!(containedType instanceof Class)) {
    5665                                return builder;
    5766                        }
     67                        b.append(" ");
     68
    5869                        Class<?> containedClass = (Class<?>) containedType;
    59                         StringBuilder b = new StringBuilder();
    60                         b.append("l ");
    6170                        FramsClassAnnotation fca = containedClass.getAnnotation(FramsClassAnnotation.class);
    6271                        if (fca == null) {
    63                                 log.error("the class is not annotated: " + containedClass);
    64                                 return builder;
     72                                throw new ConstructionException().msg("the contained class is not annotated").arg("class", containedClass);
    6573                        }
    6674                        b.append(getName(fca, containedClass));
     75                        //TODO parametrize this
    6776                        if (map) {
    6877                                b.append(" name");
    … …  
    109118                                return builder;
    110119                        }
     120
    111121
    112122                        // builder.type("o " + (cl).getCanonicalName());
    … …  
    174184                        }
    175185                        if (argsNum == 1) {
    176                                 return n.startsWith("set") ? Strings.uncapitalize(n.substring(3)) : n;
     186                                if (n.startsWith("set")) {
     187                                        return Strings.uncapitalize(n.substring(3));
     188                                }
     189                                if (n.startsWith("add")) {
     190                                        return Strings.uncapitalize(n.substring(3));
     191                                }
     192                                if (n.startsWith("remove")) {
     193                                        return Strings.uncapitalize(n.substring(6));
     194                                }
     195                                return n;
    177196                        }
    178197                        log.error("invalid number of arguments");

  • java/main/src/main/java/com/framsticks/params/InvalidOperationException.java

    r90 r99  
    11package com.framsticks.params;
    22
    3 import com.framsticks.util.FramsticksException;
     3import com.framsticks.util.UnsupportedOperationException;
    44
    55@SuppressWarnings("serial")
    6 public class InvalidOperationException extends FramsticksException {
     6public class InvalidOperationException extends UnsupportedOperationException {
    77
    88}

  • java/main/src/main/java/com/framsticks/params/ListAccess.java

    r97 r99  
    55import static com.framsticks.util.lang.Containers.filterInstanceof;
    66
     7import com.framsticks.params.types.EventParam;
    78import com.framsticks.params.types.ProcedureParam;
    89
    … …  
    1314
    1415        final AccessInterface elementAccess;
     16        final String containedTypeName;
     17
     18        protected final ParamBuilder paramBuilder;
    1519
    1620        public ListAccess(AccessInterface elementAccess) {
    1721                this.elementAccess = elementAccess;
     22                this.containedTypeName = elementAccess.getId();
     23                paramBuilder = elementAccess.buildParam(new ParamBuilder());
    1824        }
    1925
    … …  
    4854
    4955        @Override
    50         public void copyFrom(AccessInterface src) {
    51         }
    52 
    53         @Override
    5456        public void save(SinkInterface sink) {
    5557                for (CompositeParam p : filterInstanceof(getParams(), CompositeParam.class)) {
    … …  
    7072        }
    7173
    72         public abstract String computeIdentifierFor(Object selected);
     74        /**
     75         * @return the containedTypeName
     76         */
     77        public String getContainedTypeName() {
     78                return containedTypeName;
     79        }
    7380
    7481        @Override
    … …  
    8592        @Override
    8693        public Object call(String id, Object[] arguments) {
    87                 throw new InvalidOperationException().msg("list access does not support calling methods").arg("id", id);
     94                throw new InvalidOperationException().msg("list access does not support calling methods").arg("id", id).arg("access", this);
    8895        }
    8996
    9097        @Override
    9198        public Object call(ProcedureParam param, Object[] arguments) {
    92                 throw new InvalidOperationException().msg("list access does not support calling methods").arg("param", param);
     99                throw new InvalidOperationException().msg("list access does not support calling methods").arg("param", param).arg("access", this);
    93100        }
    94101
     102        @Override
     103        public void reg(EventParam param, EventListener<?> listener) {
     104                throw new InvalidOperationException().msg("list access does not support registering events").arg("param", param).arg("access", this);
     105        }
     106
     107        @Override
     108        public void regRemove(EventParam param, EventListener<?> listener) {
     109                throw new InvalidOperationException().msg("list access does not support registering events").arg("param", param).arg("access", this);
     110        }
     111
     112
     113        @Override
     114        public String toString() {
     115                StringBuilder b = new StringBuilder();
     116                b.append("list of ").append(containedTypeName);
     117                if (getSelected() != null) {
     118                        b.append("[").append(getParamCount()).append("]");
     119                }
     120                return b.toString();
     121        }
    95122};

  • java/main/src/main/java/com/framsticks/params/Param.java

    r96 r99  
    9797
    9898        public boolean isUserHidden() {
    99                 return (flags & Flags.USERHIDDEN) != 0;
     99                return (flags & ParamFlags.USERHIDDEN) != 0;
    100100        }
    101101

  • java/main/src/main/java/com/framsticks/params/ParamBuilder.java

    r97 r99  
    77import com.framsticks.util.FramsticksException;
    88import com.framsticks.util.Misc;
     9import com.framsticks.util.lang.FlagsUtil;
    910import com.framsticks.util.lang.Strings;
    1011
    … …  
    6667        private int extra = 0;
    6768
    68         String containedTypeName;
     69        protected String containedTypeName;
     70
     71        protected String eventArgumentTypeName;
    6972
    7073        protected Class<?> storageType;
    … …  
    116119        }
    117120
     121        public ParamBuilder containedTypeName(String containedTypeName) {
     122                this.containedTypeName = containedTypeName;
     123                return this;
     124        }
     125
    118126        /**
    119127         * @return the resultType
    … …  
    160168        public String getUid() {
    161169                return uid;
     170        }
     171
     172        public ParamBuilder uid(String uid) {
     173                this.uid = uid;
     174                return this;
    162175        }
    163176
    … …  
    322335                        case 'e': {
    323336                                type(EventParam.class);
    324                                 break;
    325                         }
    326                         case 'l': {
    327                                 containedTypeName = second;
    328                                 if (third != null) {
    329                                         type(UniqueListParam.class);
    330                                         uid = third;
    331                                 } else {
    332                                         type(ArrayListParam.class);
    333                                 }
    334                                 break;
    335                         }
    336                         default:{
    337                                 log.error("unknown type: " + first);
    338                                 return this;
    339                         }
    340                 }
     337                        eventArgumentTypeName(second);
     338                        break;
     339                }
     340                case 'l': {
     341                        containedTypeName = second;
     342                        if (third != null) {
     343                                type(UniqueListParam.class);
     344                                uid = third;
     345                        } else {
     346                                type(ArrayListParam.class);
     347                        }
     348                        break;
     349                }
     350                default: {
     351                        log.error("unknown type: " + first);
     352                        return this;
     353                }
     354                }
     355                return this;
     356        }
     357
     358        public ParamBuilder eventArgumentTypeName(String eventArgumentTypeName) {
     359                this.eventArgumentTypeName = eventArgumentTypeName;
    341360                return this;
    342361        }
    … …  
    438457                        id(paramEntryValues[0]);
    439458                        group(Integer.valueOf(paramEntryValues[1]));
    440                         flags(Flags.read(paramEntryValues[2]));
     459                        flags(FlagsUtil.read(ParamFlags.class, paramEntryValues[2]));
    441460                        name(paramEntryValues[3]);
    442461                        type(paramEntryValues[4]);
    … …  
    464483                                break;
    465484                        case FLAGS_FIELD:
    466                                 flags(Flags.read(value));
     485                                flags(FlagsUtil.read(ParamFlags.class, value));
    467486                                break;
    468487                        case HELP_FIELD:
    … …  
    492511        }
    493512
     513        /**
     514         * @return the eventArgumentTypeName
     515         */
     516        public String getEventArgumentTypeName() {
     517                return eventArgumentTypeName;
     518        }
     519
    494520        public Class<?> getStorageType() {
    495521                return storageType;
    496         }
    497 
    498         public ParamBuilder forAccess(AccessInterface access) {
    499                 return name(access.getId()).type("o " + access.getId());
    500522        }
    501523

  • java/main/src/main/java/com/framsticks/params/ParamCandidate.java

    r90 r99  
    7373        protected final OneTime<Method> getter = new OneTime<>("getter");
    7474        protected final OneTime<Method> caller = new OneTime<>("caller");
     75        protected final OneTime<Method> adder = new OneTime<>("adder");
     76        protected final OneTime<Method> remover = new OneTime<>("remover");
    7577
    7678        protected final List<ParamAnnotation> annotations = new LinkedList<>();
    … …  
    142144
    143145        /**
     146         * @return the getter
     147         */
     148        public Method getAdder() {
     149                return adder.get();
     150        }
     151
     152        /**
     153         * @return the getter
     154         */
     155        public Method getRemover() {
     156                return remover.get();
     157        }
     158
     159        /**
    144160         * @return the annotations
    145161         */
    … …  
    150166        void validate() throws ConstructionException {
    151167                try {
     168                        if (adder.has() != remover.has()) {
     169                                throw new ConstructionException().msg("only one of event manipulator methods is defined");
     170                        }
     171                        if (adder.has() && remover.has()) {
     172                                return;
     173                        }
    152174                        if (caller.has()) {
    153175                                if (!isPublic(caller)) {
    … …  
    174196                                throw new ConstructionException().msg("missing getter or field");
    175197                        }
     198                        if (getter.has() || field.has() || setter.has()) {
     199                                if (type.get().equals(Void.TYPE)) {
     200                                        throw new ConstructionException().msg("type of field is void");
     201                                }
     202                        }
    176203                } catch (ConstructionException e) {
    177204                        throw e.arg("in", this);
    … …  
    183210                        return false;
    184211                }
     212                if (adder.has() || remover.has()) {
     213                        return false;
     214                }
    185215                if (Collection.class.isAssignableFrom(getRawType())) {
    186216                        return false;
    … …  
    197227        boolean isReadOnly() {
    198228                if (caller.has()) {
     229                        return false;
     230                }
     231                if (adder.has() || remover.has()) {
    199232                        return false;
    200233                }
    … …  
    229262                        }
    230263                        Type[] ps = m.getGenericParameterTypes();
     264                        Class<?>[] pts = m.getParameterTypes();
    231265                        if (ps.length == 0) {
     266                                if (m.getReturnType().equals(Void.TYPE)) {
     267                                        throw new ConstructionException().msg("failed to add getter of void return type");
     268                                }
    232269                                getter.set(m);
    233270                                setType(m.getGenericReturnType());
    … …  
    235272                        }
    236273                        if (ps.length == 1) {
     274                                if (pts[0].equals(EventListener.class)) {
     275                                        if (member.getName().startsWith("add")) {
     276                                                adder.set(m);
     277                                                setType(ps[0]);
     278                                                return;
     279                                        }
     280                                        if (member.getName().startsWith("remove")) {
     281                                                remover.set(m);
     282                                                setType(ps[0]);
     283                                                return;
     284                                        }
     285                                        throw new ConstructionException().msg("invalid name of event manipulator").arg("method", m).arg("in", this);
     286                                }
    237287                                setter.set(m);
    238288                                setType(ps[0]);
    … …  
    251301                int f = 0;
    252302                if (isReadOnly()) {
    253                         f |= Flags.READONLY;
     303                        f |= ParamFlags.READONLY;
    254304                }
    255305                return f;

  • java/main/src/main/java/com/framsticks/params/PropertiesAccess.java

    r96 r99  
    44import java.util.Map;
    55
     6import com.framsticks.params.types.EventParam;
    67import com.framsticks.params.types.ProcedureParam;
    78
    … …  
    9798        @Override
    9899        public Object call(String id, Object[] arguments) {
    99                 throw new InvalidOperationException().msg("list access does not support calling methods").arg("id", id);
     100                throw new InvalidOperationException().msg("properties access does not support calling methods").arg("id", id);
    100101        }
    101102
    102103        @Override
    103104        public Object call(ProcedureParam param, Object[] arguments) {
    104                 throw new InvalidOperationException().msg("list access does not support calling methods").arg("param", param);
     105                throw new InvalidOperationException().msg("properties access does not support calling methods").arg("param", param);
     106        }
     107
     108        @Override
     109        public void reg(EventParam param, EventListener<?> listener) {
     110                throw new InvalidOperationException().msg("properties access does not support registering events").arg("param", param).arg("access", this);
     111        }
     112
     113        @Override
     114        public void regRemove(EventParam param, EventListener<?> listener) {
     115                throw new InvalidOperationException().msg("properties access does not support registering events").arg("param", param).arg("access", this);
    105116        }
    106117

  • java/main/src/main/java/com/framsticks/params/ReflectionAccess.java

    r98 r99  
    1717
    1818import com.framsticks.params.annotations.AutoAppendAnnotation;
     19import com.framsticks.params.types.EventParam;
    1920import com.framsticks.params.types.ProcedureParam;
    2021import com.framsticks.util.FramsticksException;
    … …  
    5758                }
    5859
     60                public interface ReflectedAdder{
     61                        public void reg(Object object, EventListener<?> listener) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException;
     62                }
     63
     64                public interface ReflectedRemover{
     65                        public void regRemove(Object object, EventListener<?> listener) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException;
     66                }
     67
    5968                protected final Map<ValueParam, ReflectedSetter> setters = new IdentityHashMap<>();
    6069                protected final Map<ValueParam, ReflectedGetter> getters = new IdentityHashMap<>();
    6170                protected final Map<ProcedureParam, ReflectedCaller> callers = new IdentityHashMap<>();
     71                protected final Map<EventParam, ReflectedAdder> adders = new IdentityHashMap<>();
     72                protected final Map<EventParam, ReflectedRemover> removers = new IdentityHashMap<>();
     73
    6274                protected final List<Method> autoAppendMethods = new ArrayList<>();
    6375
    … …  
    100112                                }
    101113
     114                                for (final EventParam ep : filterInstanceof(framsClass.getParamEntries(), EventParam.class)) {
     115                                        if (!candidates.containsKey(ep.getId())) {
     116                                                log.trace("java class does not implement the event param " + ep);
     117                                                continue;
     118                                        }
     119                                        ParamCandidate ec = candidates.get(ep.getId());
     120                                        final Method adder = ec.getAdder();
     121                                        final Method remover = ec.getRemover();
     122
     123                                        backend.adders.put(ep, new ReflectedAdder() {
     124
     125                                                @Override
     126                                                public void reg(Object object, EventListener<?> listener) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
     127                                                        adder.invoke(object, listener);
     128                                                }
     129                                        });
     130
     131                                        backend.removers.put(ep, new ReflectedRemover() {
     132
     133                                                @Override
     134                                                public void regRemove(Object object, EventListener<?> listener) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
     135                                                        remover.invoke(object, listener);
     136                                                }
     137                                        });
     138                                }
     139
    102140                                for (final ValueParam vp : filterInstanceof(framsClass.getParamEntries(), ValueParam.class)) {
    103141                                        if (!candidates.containsKey(vp.getId())) {
    … …  
    105143                                        }
    106144                                        ParamCandidate pc = candidates.get(vp.getId());
    107                                         if (pc.isReadOnly() && !vp.hasFlag(Flags.READONLY)) {
     145                                        if (pc.isReadOnly() && !vp.hasFlag(ParamFlags.READONLY)) {
    108146                                                throw new ConstructionException().msg("readonly state conflict").arg("param", vp);
    109147                                        }
    … …  
    200238        }
    201239
    202         public ReflectionAccess(Class<?> reflectedClass) throws ConstructionException {
    203                 this(reflectedClass, FramsClass.build().forClass(reflectedClass));
    204         }
    205 
    206240        public static boolean typeMatch(Class<?> a, Class<?> b) {
    207                 assert !b.isPrimitive();
     241                if (b.isPrimitive()) {
     242                        throw new FramsticksException().msg("failed to match type, right argument is primitive").arg("left", a).arg("right", b);
     243                }
    208244                if (!a.isPrimitive()) {
    209245                        return a.equals(b);
    … …  
    219255                        return b.equals(Boolean.class);
    220256                }
    221                 assert false;
    222                 return false;
    223         }
    224 
    225         public ReflectionAccess(Class<?> reflectedClass, FramsClass framsClass) throws ConstructionException {
     257                throw new FramsticksException().msg("failed to match types").arg("left", a).arg("right", b);
     258        }
     259
     260
     261
     262
     263        public ReflectionAccess(Class<?> javaClass) throws ConstructionException {
     264                this(javaClass, FramsClass.build().forClass(javaClass));
     265        }
     266
     267
     268        public ReflectionAccess(Class<?> javaClass, FramsClass framsClass) throws ConstructionException {
     269                this(javaClass, framsClass, Backend.getOrCreateFor(javaClass, framsClass));
     270        }
     271
     272        protected ReflectionAccess(Class<?> javaClass, FramsClass framsClass, Backend backend) throws ConstructionException {
    226273                super(framsClass);
    227                 this.javaClass = reflectedClass;
    228                 this.backend = Backend.getOrCreateFor(reflectedClass, framsClass);
    229         }
    230 
     274                this.javaClass = javaClass;
     275                this.backend = backend;
     276        }
     277
     278        @Override
     279        public ReflectionAccess cloneAccess() throws ConstructionException {
     280                return new ReflectionAccess(javaClass, framsClass, backend);
     281        }
    231282
    232283        @Override
    … …  
    268319                } catch (FramsticksException e) {
    269320                        throw e.arg("param", param).arg("value", value).arg("access", this);
     321                }
     322        }
     323
     324        @Override
     325        public void reg(EventParam param, EventListener<?> listener) {
     326                try {
     327                        try {
     328                                if (object == null) {
     329                                        throw new FramsticksException().msg("no object set");
     330                                }
     331
     332                                backend.adders.get(param).reg(object, listener);
     333                                return;
     334                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
     335                                throw new FramsticksException().msg("failed to add listener").cause(e);
     336                        }
     337                } catch (FramsticksException e) {
     338                        throw e.arg("param", param).arg("access", this);
     339                }
     340        }
     341
     342        @Override
     343        public void regRemove(EventParam param, EventListener<?> listener) {
     344                try {
     345                        try {
     346                                if (object == null) {
     347                                        throw new FramsticksException().msg("no object set");
     348                                }
     349
     350                                backend.removers.get(param).regRemove(object, listener);
     351                                return;
     352                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
     353                                throw new FramsticksException().msg("failed to remove listener").cause(e);
     354                        }
     355                } catch (FramsticksException e) {
     356                        throw e.arg("param", param).arg("access", this);
    270357                }
    271358        }
    … …  
    352439        }
    353440
    354         @Override
    355         public ReflectionAccess cloneAccess() throws ConstructionException {
    356                 return new ReflectionAccess(javaClass, framsClass);
    357         }
    358441
    359442        @Override
    … …  
    368451        }
    369452
    370         @Override
    371         public String toString() {
    372                 StringBuilder b = new StringBuilder();
    373                 b.append(framsClass);
    374                 if (object != null) {
    375                         b.append("(").append(object).append(")");
    376                 }
    377                 return b.toString();
    378         }
    379453
    380454        @Override

  • java/main/src/main/java/com/framsticks/params/Registry.java

    r98 r99  
    4646                register(javaClass);
    4747                associate(javaClass, putFramsClass(FramsClass.build().forClass(javaClass)));
     48                for (Class<?> r : javaClass.getAnnotation(FramsClassAnnotation.class).register()) {
     49                        registerAndBuild(r);
     50                }
    4851                return this;
    4952        }
    … …  
    122125        }
    123126
     127        public FramsClass getFramsClassForJavaClass(Class<?> javaClass) {
     128                return javaToFramsAssociation.get(javaClass);
     129        }
     130
    124131        public Set<Class<?>> getReflectedClasses() {
    125132                return javaClasses.getValues();

  • java/main/src/main/java/com/framsticks/params/SimpleAbstractAccess.java

    r98 r99  
    66import org.apache.log4j.Logger;
    77
    8 import com.framsticks.util.UnimplementedException;
     8import com.framsticks.params.types.ObjectParam;
     9import com.framsticks.util.FramsticksException;
     10import static com.framsticks.params.SetStateFlags.*;
    911
    1012/**
    … …  
    105107        @Override
    106108        public <T> int set(ValueParam param, T value) {
    107                 int flags = 0;
    108109
    109110                //String id = param.getEffectiveId();
    … …  
    115116                                internalSet(param, casted);
    116117                        }
    117                         flags = result.getFlags();
     118                        return result.getFlags();
    118119                } catch (CastFailure e) {
    119                         log.error("casting failure while set: ", e);
    120                 }
    121                 return flags;
     120                        throw new FramsticksException()
     121                                .msg("casting failure while set")
     122                                .arg("param", param)
     123                                .arg("value", value)
     124                                .arg("value's type", (value == null ? "<null>" : value.getClass().getCanonicalName()))
     125                                .arg("in", this).cause(e);
     126                }
    122127        }
    123128
    … …  
    167172                        set(i, max);
    168173                }
    169         }
    170 
    171         @Override
    172         public void copyFrom(AccessInterface src) {
    173                 throw new UnimplementedException();
    174                 // clearValues();
    175                 //TODO: iterate over self, and pull from src
    176                 /*
    177                 for (int i = 0; i < src.getFramsClass().size(); i++) {
    178                         this.set(i, src.get(i, Object.class));
    179                 }
    180                 */
    181174        }
    182175
    … …  
    257250                                continue;
    258251                        }
    259                         if ((param.getFlags() & Flags.DONTLOAD) != 0) {
     252                        if ((param.getFlags() & ParamFlags.DONTLOAD) != 0) {
    260253                                log.debug("DontLoad flag was set - not loading...");
    261254                        } else {
    262255                                int retFlags = this.set((ValueParam) param, entry.value);
    263                                 if ((retFlags & (Flags.PSET_HITMIN | Flags.PSET_HITMAX)) != 0) {
    264                                         String which = ((retFlags & Flags.PSET_HITMIN) != 0) ? "small" : "big";
     256                                if ((retFlags & (PSET_HITMIN | PSET_HITMAX)) != 0) {
     257                                        String which = ((retFlags & PSET_HITMIN) != 0) ? "small" : "big";
    265258                                        log.warn("value of key '" + entry.key + "' was too " + which + ", adjusted");
    266259                                }
    … …  
    304297        }*/
    305298
     299        @Override
     300        public String toString() {
     301                StringBuilder b = new StringBuilder();
     302                b.append(framsClass);
     303                if (getSelected() != null) {
     304                        b.append("(").append(getSelected()).append(")");
     305                }
     306                return b.toString();
     307        }
     308
     309        @Override
     310        public ParamBuilder buildParam(ParamBuilder builder) {
     311                return builder.name(getId()).type(ObjectParam.class).containedTypeName(getId());
     312        }
    306313
    307314}

  • java/main/src/main/java/com/framsticks/params/UniqueListAccess.java

    r98 r99  
    11package com.framsticks.params;
    22
     3import com.framsticks.params.types.UniqueListParam;
    34import com.framsticks.util.FramsticksException;
    45import com.framsticks.util.UnimplementedException;
    … …  
    8081                        return null;
    8182                }
    82                 return Param.build().id(Integer.toString(i)).forAccess(elementAccess).finish(CompositeParam.class);
     83                Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
     84                while (i > 0 && iterator.hasNext()) {
     85                        iterator.next();
     86                        --i;
     87                }
     88                if (i > 0) {
     89                        return null;
     90                }
     91                if (!iterator.hasNext()) {
     92                        return null;
     93                }
     94                return paramBuilder.id(getUidOf(iterator.next().getValue())).finish(CompositeParam.class);
    8395        }
    8496
    … …  
    96108                        return null;
    97109                }
    98                 return Param.build().id(id).forAccess(elementAccess).finish(CompositeParam.class);
     110                return paramBuilder.id(id).finish(CompositeParam.class);
    99111        }
    100112
    … …  
    148160                String uid = elementAccess.get(uidName, String.class);
    149161                elementAccess.select(tmp);
    150                 if (uid == null) {
    151                         return null;
    152                 }
    153162                return uid;
    154163        }
    … …  
    233242        }
    234243
    235         @Override
    236244        public String computeIdentifierFor(Object selected) {
    237245                String uid = getUidOf(selected);
    … …  
    260268                                        @Override
    261269                                        public Param next() {
    262                                                 return Param.build().id(internal.next().getKey()).forAccess(elementAccess).finish();
     270                                                return paramBuilder.id(internal.next().getKey()).finish();
    263271                                        }
    264272
    … …  
    282290                return getParam(number);
    283291        }
     292
     293        @Override
     294        public ParamBuilder buildParam(ParamBuilder builder) {
     295                return builder.name(containedTypeName + " list").type(UniqueListParam.class).containedTypeName(containedTypeName).uid(uidName);
     296        }
     297
    284298}

  • java/main/src/main/java/com/framsticks/params/Util.java

    r90 r99  
    3636        }
    3737
    38         public static int copyParams(AccessInterface to, AccessInterface from) {
     38        public static int takeAllNonNullValues(AccessInterface to, AccessInterface from) {
     39                int copied = 0;
     40                for (ValueParam f : filterInstanceof(from.getParams(), ValueParam.class)) {
     41                        Object v = from.get(f, Object.class);
     42                        if (v == null) {
     43                                continue;
     44                        }
     45                        to.set(f, v);
     46                        ++copied;
     47                }
     48                return copied;
     49        }
     50
     51        public static int copyExistingParamsTypeSafe(AccessInterface to, AccessInterface from) {
    3952                int copied = 0;
    4053                for (ValueParam f : filterInstanceof(from.getParams(), ValueParam.class)) {

  • java/main/src/main/java/com/framsticks/params/annotations/FramsClassAnnotation.java

    r90 r99  
    1313
    1414        String[] order() default {};
     15        Class<?>[] register() default {};
    1516}

  • java/main/src/main/java/com/framsticks/params/types/EventParam.java

    r87 r99  
    1212public class EventParam extends Param {
    1313
     14        protected final String eventArgumentTypeName;
    1415
    1516
    … …  
    1920        public EventParam(ParamBuilder builder) {
    2021                super(builder);
     22                eventArgumentTypeName = builder.getEventArgumentTypeName();
    2123        }
    2224
    2325        @Override
    2426        public Class<?> getStorageType() {
    25                 return Void.class;
     27                return Void.TYPE;
    2628        }
    2729
    2830        @Override
    2931        public String getFramsTypeName() {
    30                 return "e";
     32                return eventArgumentTypeName != null ? "e " + eventArgumentTypeName : "e";
    3133        }
    3234}

  • java/main/src/main/java/com/framsticks/params/types/NumberParam.java

    r87 r99  
    22
    33import com.framsticks.params.CastFailure;
    4 import com.framsticks.params.Flags;
    54import com.framsticks.params.ParamBuilder;
    65import com.framsticks.params.PrimitiveParam;
    … …  
    109
    1110import javax.annotation.concurrent.Immutable;
     11import static com.framsticks.params.SetStateFlags.*;
    1212
    1313/**
    … …  
    4040                }
    4141                if (min != null && v.compareTo(getMin(type)) < 0) {
    42                         return new ReassignResult<T>(getMin(type), Flags.PSET_HITMIN);
     42                        return new ReassignResult<T>(getMin(type), PSET_HITMIN);
    4343                }
    4444                if (max != null && v.compareTo(getMax(type)) > 0) {
    45                         return new ReassignResult<T>(getMax(type), Flags.PSET_HITMAX);
     45                        return new ReassignResult<T>(getMax(type), PSET_HITMAX);
    4646                }
    4747                return ReassignResult.create(v);

  • java/main/src/main/java/com/framsticks/params/types/ProcedureParam.java

    r97 r99  
    5454        @Override
    5555        public Class<?> getStorageType() {
    56                 return Void.class;
     56                return Void.TYPE;
    5757        }
    5858
Note: See TracChangeset for help on using the changeset viewer.