Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jacorb.notification.util;
  
  /*
   *        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.
  *
  */
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

Author(s):
Alphonse Bendt
 
 
 public abstract class PropertySet
 {
     protected static final ORB sORB = org.omg.CORBA.ORBSingleton.init();
 
     protected static final PropertyError[] PROPERTY_ERROR_ARRAY_TEMPLATE = new PropertyError[0];
 
     protected static final PropertyRange EMPTY_PROPERTY_RANGE = new PropertyRange(
             .create_any(), .create_any());
 
     ////////////////////////////////////////
 
     protected final Logger logger_ = LogUtil.getLogger(getClass().getName());
 
 
     private boolean modified_ = true;
 
     private final Map<StringAnyproperties_ = new HashMap<StringAny>();
 
     private Property[] arrayView_ = null;
 
     ////////////////////////////////////////
 
     public void addPropertySetListener(String[] propsPropertySetListener listener)
     {
         for (int x = 0; x < props.length; ++x)
         {
             addPropertySetListener(props[x], listener);
         }
     }
 
     public void addPropertySetListener(String propertyPropertySetListener listener)
     {
         final List<PropertySetListener_list;
 
         if (!.containsKey(property))
         {
             _list = new ArrayList<PropertySetListener>();
             .put(property_list);
         }
         else
         {
             _list = (List<PropertySetListener>) .get(property);
         }
 
         _list.add(listener);
     }
 
     public synchronized Property[] toArray()
     {
         if ( == null || )
         {
             Property[] _props = new Property[.size()];
 
             Iterator<Stringi = .keySet().iterator();
             int x = 0;
            while (i.hasNext())
            {
                String _key = (Stringi.next();
                _props[x++] = new Property(_key, (Any.get(_key));
            }
             = _props;
             = false;
        }
        return ;
    }
    public Map<StringAnytoMap()
    {
        return Collections.unmodifiableMap();
    }
    public String toString()
    {
        return .toString();
    }
    public boolean containsKey(String propertyName)
    {
        return .containsKey(propertyName);
    }
    public Any get(String propertyName)
    {
        return (Any.get(propertyName);
    }
    protected void set_properties(Property[] props)
    {
        final HashSet<PropertySetListener_toBeNotified = new HashSet<PropertySetListener>();
        for (int x = 0; x < props.length; ++x)
        {
            Any _oldValue = null;
            if (.containsKey(props[x].))
            {
                _oldValue = (Any.get(props[x].);
            }
            .put(props[x].props[x].);
            if (.containsKey(props[x].))
            {
                if (!props[x]..equals(_oldValue))
                {
                    _toBeNotified.addAll(.get(props[x].));
                }
            }
        }
        synchronized (this)
        {
             = true;
        }
        Iterator<?> i = _toBeNotified.iterator();
        while (i.hasNext())
        {
            try
            {
                ((PropertySetListeneri.next()).actionPropertySetChanged(this);
            } catch (Exception e)
            {
                .error("exception in listener"e);
            }
        }
    }
    abstract Set<?> getValidNames();
    protected void checkPropertyExistence(Property[] propsList<PropertyErrorerrorList)
    {
        for (int x = 0; x < props.length; ++x)
        {
            if (!getValidNames().contains(props[x].))
            {
                errorList.add(badProperty(props[x].));
            }
        }
    }
    protected PropertyError badProperty(String name)
    {
        return new PropertyError(.name);
    }
    protected PropertyError badType(String name)
    {
        return new PropertyError(.name);
    }
    ////////////////////////////////////////
    public static Property[] map2Props(Map<?, ?> props)
    {
        Property[] _ps = new Property[props.size()];
        Iterator<?> i = props.keySet().iterator();
        int x = 0;
        while (i.hasNext())
        {
            String _key = (Stringi.next();
            _ps[x++] = new Property(_key, (Anyprops.get(_key));
        }
        return _ps;
    }
New to GrepCode? Check out our FAQ X