/*

 * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

import java.beans.ConstructorProperties;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedMap;

import java.util.SortedSet;

import java.util.TreeMap;

import java.util.TreeSet;

import javax.management.openmbean.ArrayType;

import javax.management.openmbean.CompositeType;

import javax.management.openmbean.OpenDataException;

import javax.management.openmbean.OpenType;

import javax.management.openmbean.SimpleType;

import javax.management.openmbean.TabularType;

public interface TigerMXBean {

    class Point {

        @ConstructorProperties({"x", "y"})

        public Point(double x, double y) {

            this.x = x;

            this.y = y;

        }

        public boolean equals(Object o) {

            if (!(o instanceof Point))

                return false;

            Point p = (Point) o;

            return p.x == x && p.y == y;

        }

        public int hashCode() {

            return new Double(x).hashCode() ^ new Double(y).hashCode();

        }

        public double getX() {return x;}

        public double getY() {return y;}

        private final double x, y;

    }

    Point Point = new Point(1.5, 2.5);

    CompositeType PointType = MerlinMXBean.CompositeTypeMaker.make(

        Point.class.getName(),

        Point.class.getName(),

        new String[] {"x", "y"},

        new String[] {"x", "y"},

        new OpenType[] {SimpleType.DOUBLE, SimpleType.DOUBLE});

    Point getPoint();

    void setPoint(Point x);

    Point opPoint(Point x, Point y);

    enum Tuiseal {AINMNEACH, GAIRMEACH, GINIDEACH, TABHARTHACH}

    Tuiseal Enum = Tuiseal.GINIDEACH;

    SimpleType EnumType = SimpleType.STRING;

    Tuiseal getEnum();

    void setEnum(Tuiseal x);

    Tuiseal opEnum(Tuiseal x, Tuiseal y);

    List<String> StringList = Arrays.asList(new String[] {"a", "b", "x"});

    ArrayType StringListType =

        MerlinMXBean.ArrayTypeMaker.make(1, SimpleType.STRING);

    List<String> getStringList();

    void setStringList(List<String> x);

    List<String> opStringList(List<String> x, List<String> y);

    Set<String> StringSet = new HashSet(StringList);

    ArrayType StringSetType = StringListType;

    Set<String> getStringSet();

    void setStringSet(Set<String> x);

    Set<String> opStringSet(Set<String> x, Set<String> y);

    SortedSet<String> SortedStringSet = new TreeSet(StringList);

    ArrayType SortedStringSetType = StringListType;

    SortedSet<String> getSortedStringSet();

    void setSortedStringSet(SortedSet<String> x);

    SortedSet<String> opSortedStringSet(SortedSet<String> x,

                                        SortedSet<String> y);

    Map<String,List<String>> XMap = Collections.singletonMap("yo", StringList);

    String XMapTypeName =

        "java.util.Map<java.lang.String, java.util.List<java.lang.String>>";

    CompositeType XMapRowType = MerlinMXBean.CompositeTypeMaker.make(

        XMapTypeName, XMapTypeName,

        new String[] {"key", "value"},

        new String[] {"key", "value"},

        new OpenType[] {SimpleType.STRING, StringListType});

    TabularType XMapType =

        TabularTypeMaker.make(XMapTypeName, XMapTypeName, XMapRowType,

                              new String[] {"key"});

    Map<String,List<String>> getXMap();

    void setXMap(Map<String,List<String>> x);

    Map<String,List<String>> opXMap(Map<String,List<String>> x,

                                    Map<String,List<String>> y);

    SortedMap<String,String> XSortedMap =

        new TreeMap(Collections.singletonMap("foo", "bar"));

    String XSortedMapTypeName =

        "java.util.SortedMap<java.lang.String, java.lang.String>";

    CompositeType XSortedMapRowType = MerlinMXBean.CompositeTypeMaker.make(

        XSortedMapTypeName, XSortedMapTypeName,

        new String[] {"key", "value"},

        new String[] {"key", "value"},

        new OpenType[] {SimpleType.STRING, SimpleType.STRING});

    TabularType XSortedMapType =

        TabularTypeMaker.make(XSortedMapTypeName, XSortedMapTypeName,

                              XSortedMapRowType, new String[] {"key"});

    SortedMap<String,String> getXSortedMap();

    void setXSortedMap(SortedMap<String,String> x);

    SortedMap<String,String> opXSortedMap(SortedMap<String,String> x,

                                          SortedMap<String,String> y);

    // For bug 6319960, try constructing Set and Map with non-Comparable

    Set<Point> PointSet = new HashSet(Collections.singleton(Point));

    ArrayType PointSetType =

        MerlinMXBean.ArrayTypeMaker.make(1, PointType);

    Set<Point> getPointSet();

    void setPointSet(Set<Point> x);

    Set<Point> opPointSet(Set<Point> x, Set<Point> y);

    Map<Point,Point> PointMap = Collections.singletonMap(Point, Point);

    String PointMapTypeName =

        "java.util.Map<" + Point.class.getName() + ", " +

        Point.class.getName() + ">";

    CompositeType PointMapRowType = MerlinMXBean.CompositeTypeMaker.make(

        PointMapTypeName, PointMapTypeName,

        new String[] {"key", "value"},

        new String[] {"key", "value"},

        new OpenType[] {PointType, PointType});

    TabularType PointMapType =

        TabularTypeMaker.make(PointMapTypeName, PointMapTypeName,

                              PointMapRowType, new String[] {"key"});

    Map<Point,Point> getPointMap();

    void setPointMap(Map<Point,Point> x);

    Map<Point,Point> opPointMap(Map<Point,Point> x, Map<Point,Point> y);

    static class TabularTypeMaker {

        static TabularType make(String typeName, String description,

                                CompositeType rowType, String[] indexNames) {

            try {

                return new TabularType(typeName, description, rowType,

                                       indexNames);

            } catch (OpenDataException e) {

                throw new Error(e);

            }

        }

    }

}