Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jacorb.notification.filter.impl;
  
  /*
   *        JacORB - a free Java ORB
   *
   *   Copyright (C) 1999-2012 Gerald Brose / The JacORB Team.
   *
   *   This library is free software; you can redistribute it and/or
   *   modify it under the terms of the GNU Library General Public
  *   License as published by the Free Software Foundation; either
  *   version 2 of the License, or (at your option) any later version.
  *
  *   This library 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
  *   Library General Public License for more details.
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this library; if not, write to the Free
  *   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  */
 
Provide the Basic operations needed to evaluate filter expressions on Anys.

Author(s):
Alphonse Bendt
 
 
 public class DefaultETCLEvaluator implements ETCLEvaluator
 {
     private static final String NAME = "name";
 
     private static final String VALUE = "value";
 
     ////////////////////////////////////////
 
     private final Logger logger_;
 
     private final DynAnyFactory dynAnyFactory_;
 
     private final ORB orb_;
 
     private final Any TRUE_ANY;
 
     private final Any FALSE_ANY;
 
     ////////////////////////////////////////
 
     public DefaultETCLEvaluator(ORB orbConfiguration configDynAnyFactory dynAnyFactory)
     {
          = orb;
 
          = ((org.jacorb.config.Configurationconfig).getLogger(getClass().getName());
 
          = dynAnyFactory;
 
          = .create_any();
 
          = .create_any();
 
         .insert_boolean(true);
 
         .insert_boolean(false);
     }
 
     ////////////////////////////////////////
 
     public boolean hasDefaultDiscriminator(Any anythrows EvaluationException
     {
         try
         {
             return (any.type().default_index() != -1);
         } catch (BadKind e)
        {
            throw newEvaluationException(e);
        }
    }
    public Any evaluateExistIdentifier(Any valueString identifierthrows EvaluationException
    {
        try
        {
            evaluateIdentifier(valueidentifier);
            return ;
        } catch (EvaluationException e)
        {
            return ;
        }
    }
    public Any evaluateTypeName(Any valuethrows EvaluationException
    {
        try
        {
            TypeCode _tc = value.type();
            Any _ret = .create_any();
            _ret.insert_string(_tc.name());
            return _ret;
        } catch (BadKind e)
        {
            throw newEvaluationException(e);
        }
    }
    public Any evaluateRepositoryId(Any valuethrows EvaluationException
    {
        try
        {
            TypeCode _tc = value.type();
            Any _ret = .create_any();
            _ret.insert_string(_tc.id());
            return _ret;
        } catch (BadKind e)
        {
            throw newEvaluationException(e);
        }
    }
    public Any evaluateListLength(Any valuethrows EvaluationException
    {
        final int _length;
        switch (value.type().kind().value()) {
        case .:
            DynAny _dynAny = toDynAny(value);
            _length = _dynAny.component_count();
            break;
        case .:
            DynSequence _dynSequence = toDynSequence(value);
            _length = _dynSequence.get_length();
            break;
        default:
            throw new EvaluationException("Neither array nor sequence");
        }
        Any _any = .create_any();
        _any.insert_long(_length);
        return _any;
    }
    private String getDefaultUnionMemberName(TypeCode unionTypeCodethrows EvaluationException
    {
        try
        {
            int _defaultIndex = unionTypeCode.default_index();
            if (_defaultIndex != -1)
            {
                return unionTypeCode.member_name(_defaultIndex);
            }
        } catch (BadKind e)
        {
            throw newEvaluationException(e);
        } catch (Bounds e)
        {
            throw newEvaluationException(e);
        }
        throw new EvaluationException();
    }
    private String getUnionMemberNameFromDiscriminator(TypeCode unionTypeCodeint discriminator)
            throws EvaluationException
    {
        try
        {
            Any _any = .create_any();
            switch (unionTypeCode.discriminator_type().kind().value()) {
            case .:
                _any.insert_long(discriminator);
                break;
            case .:
                _any.insert_ulong(discriminator);
                break;
            case .:
                _any.insert_short((shortdiscriminator);
                break;
            case .:
                _any.insert_double(discriminator);
                break;
            case .:
                _any.insert_ushort((shortdiscriminator);
                break;
            }
            int _memberCount = unionTypeCode.member_count();
            try
            {
                for (int _x = 0; _x < _memberCount_x++)
                {
                    if (_any.equal(unionTypeCode.member_label(_x)))
                    {
                        return unionTypeCode.member_name(_x);
                    }
                }
            } catch (Bounds b)
            {
                // this should never happen as _x should be always < _memberCount.
                throw new RuntimeException();
            }
        } catch (BadKind e)
        {
            throw newEvaluationException(e);
        }
        throw new EvaluationException();
    }
    public Any evaluateUnion(Any valuethrows EvaluationException
    {
        String _defaultMemberName = getDefaultUnionMemberName(value.type());
        return evaluateIdentifier(value_defaultMemberName);
    }
    public Any evaluateUnion(Any valueint positionthrows EvaluationException
    {
        final DynUnion _dynUnion = toDynUnion(value);
        _dynUnion.seek(0);
        if (.isDebugEnabled())
        {
            .debug("extract idx: " + position + " from Union " + _dynUnion.type());
        }
        String _discrimName = getUnionMemberNameFromDiscriminator(value.type(), position);
        return evaluateIdentifier(_dynUnion_discrimName);
    }
    public Any evaluatePropertyList(Property[] listString name)
    {
        if (.isDebugEnabled())
        {
            .debug("evaluatePropertyList " + list);
            .debug("list length: " + list.length);
        }
        for (int x = 0; x < list.length; ++x)
        {
            if (.isDebugEnabled())
            {
                .debug(x + ": " + list[x]. + " => " + list[x].);
            }
            if (name.equals(list[x].))
            {
                return list[x].;
            }
        }
        return null;
    }
    public Any evaluateNamedValueList(Any anyString namethrows EvaluationException
    {
        try
        {
            if (.isDebugEnabled())
            {
                .debug("evaluateNamedValueList(" + any + ", " + name + ")");
            }
            final DynAny _dynAny = toDynAny(any);
            final int _count = _dynAny.component_count();
            DynAny _cursor;
            Any _ret = null;
            _dynAny.rewind();
            if (.isDebugEnabled())
            {
                .debug("Entries: " + _count);
            }
            for (int _x = 0; _x < _count_x++)
            {
                _dynAny.seek(_x);
                _cursor = _dynAny.current_component();
                _ret = evaluateNamedValue(_cursorname);
                if (_ret != null)
                {
                    break;
                }
            }
            return _ret;
        } catch (TypeMismatch e)
        {
            throw newEvaluationException(e);
        }
    }
    private Any evaluateNamedValue(DynAny anyString namethrows EvaluationException
    {
        if (.isDebugEnabled())
        {
            .debug("evaluate assoc " + name + " on a Any of type: " + any.type());
        }
        final Any _result;
        final String _anyName = evaluateIdentifier(any).extract_string();
        if (.isDebugEnabled())
        {
            .debug("test if " + name + " == " + _anyName);
        }
        if (name.equals(_anyName))
        {
            .debug("YES");
            _result = evaluateIdentifier(any);
        }
        else
        {
            _result = null;
        }
        return _result;
    }
    public Any evaluateArrayIndex(Any anyint indexthrows EvaluationException
    {
        try
        {
            if (.isDebugEnabled())
            {
                .debug("evaluate array idx " + index + " on a Any of type: " + any.type());
            }
            DynAny _dynAny = toDynAny(any);
            DynAny _cursor;
            _dynAny.rewind();
            _dynAny.seek(index);
            _cursor = _dynAny.current_component();
            if (.isDebugEnabled())
            {
                .debug("evaluation result is of type: " + _cursor.type());
            }
            return _cursor.to_any();
        } catch (TypeMismatch e)
        {
            throw newEvaluationException(e);
        }
    }
    private Any evaluateIdentifier(DynAny anyint positionthrows EvaluationException
    {
        try
        {
            final DynAny _result;
            switch (any.type().kind().value()) {
            case .:
                any.seek(position);
                _result = any.current_component();
                break;
            default:
                throw new EvaluationException("attempt to access member on non-struct");
            }
            return _result.to_any();
        } catch (TypeMismatch e)
        {
            throw newEvaluationException(e);
        }
    }
    public Any evaluateIdentifier(Any anyint positionthrows EvaluationException
    {
        if (.isDebugEnabled())
        {
            .debug("evaluate idx " + position + " on Any");
        }
        DynAny _dynAny = toDynAny(any);
        return evaluateIdentifier(_dynAnyposition);
    }
    public Any evaluateDiscriminator(Any anythrows EvaluationException
    {
        switch (any.type().kind().value()) {
        case .:
            DynUnion _dynUnion = toDynUnion(any);
            return _dynUnion.get_discriminator().to_any();
        default:
            throw new EvaluationException("any does not contain member _d");
        }
    }
            EvaluationResult elementAny sequencethrows EvaluationException
    {
        try
        {
            final DynSequence _dynSequence = DynSequenceHelper.narrow(toDynAny(sequence));
            _dynSequence.rewind();
            do
            {
                final DynAny _currentComponent = _dynSequence.current_component();
                final EvaluationResult _currentElement = EvaluationResult.fromAny(_currentComponent.to_any());
                if (element.compareTo(_currentElement) == 0)
                {
                    return .;
                }
            } while (_dynSequence.next());
            return .;
        } catch (TypeMismatch e)
        {
            throw newEvaluationException(e);
        }
    }

    
expensive
    public Any evaluateIdentifier(Any anyString identifierthrows EvaluationException
    {
        // expensive call
        DynAny _dynAny = toDynAny(any);
        // expensive call
        return evaluateIdentifier(_dynAnyidentifier);
    }
    private Any evaluateIdentifier(DynAny anyString identifierthrows EvaluationException
    {
        try
        {
            final String _strippedIdentifier = stripBackslash(identifier);
            if (.isDebugEnabled())
            {
                .debug("evaluate " + _strippedIdentifier + " on Any");
            }
            DynAny _cursor = any;
            SWITCH_LABEL:
            switch (any.type().kind().value()) {
            case .:
                .debug("Any is a struct");
                final DynStruct _dynStruct = DynStructHelper.narrow(any);
                String _currentName;
                _dynStruct.rewind();
                do
                {
                    _currentName = _dynStruct.current_member_name();
                    if (.isDebugEnabled())
                    {
                        .debug(" => " + _currentName);
                    }
                    if (_currentName.equals(_strippedIdentifier))
                    {
                        // expensive operation
                        _cursor = _dynStruct.current_component();
                        break SWITCH_LABEL;
                    }
                } while (_dynStruct.next());
                throw new EvaluationException("struct has no member " + _strippedIdentifier);
            case .:
                if (.isDebugEnabled())
                {
                    .debug("Any is a Union");
                }
                DynUnion _dynUnion = toDynUnion(any);
                if (_dynUnion.member_name().equals(_strippedIdentifier))
                {
                    _cursor = _dynUnion.member();
                }
                else
                {
                    if (.isDebugEnabled())
                    {
                        .debug(_dynUnion.member_name() + " != " + _strippedIdentifier);
                    }
                    throw new EvaluationException("member " + _strippedIdentifier
                            + " is not active on struct");
                }
                break;
            case .:
                .debug("encapsulated any");
                return evaluateIdentifier(any.get_any(), _strippedIdentifier);
            default:
                .debug("unknown " + any.type());
                return null;
            }
            if (.isDebugEnabled())
            {
                .debug("Result: " + _cursor);
            }
            if (_cursor != null && .isDebugEnabled())
            {
                .debug("evaluation result is of type: " + _cursor.type());
            }
            if (_cursor == null)
            {
                .debug("Member not found");
                throw new EvaluationException("member not found");
            }
            return _cursor.to_any();
        } catch (InvalidValue e)
        {
            throw newEvaluationException(e);
        } catch (TypeMismatch e)
        {
            throw newEvaluationException(e);
        }
    }
    ////////////////////////////////////////
    private DynAny toDynAny(Any anythrows EvaluationException
    {
        try
        {
            return .create_dyn_any(any);
        } catch (InconsistentTypeCode e)
        {
            throw newEvaluationException(e);
        }
    }
    private DynUnion toDynUnion(Any anythrows EvaluationException
    {
        return DynUnionHelper.narrow(toDynAny(any));
    }
    private DynUnion toDynUnion(DynAny dynAny)
    {
        return DynUnionHelper.narrow(dynAny);
    }
    private DynSequence toDynSequence(Any anythrows EvaluationException
    {
        return DynSequenceHelper.narrow(toDynAny(any));
    }
    private static String stripBackslash(String identifier)
    {
        StringBuffer _buffer = new StringBuffer();
        int _length = identifier.length();
        for (int _x = 0; _x < _length_x++)
        {
            if (identifier.charAt(_x) != '\\')
            {
                _buffer.append(identifier.charAt(_x));
            }
        }
        return _buffer.toString();
    }
    {
        return new EvaluationException(e.toString());
    }
New to GrepCode? Check out our FAQ X