content: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package com.aliyun.odps.io;
  
  import java.io.DataInput;
  import java.io.DataOutput;
  import java.io.IOException;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.atomic.AtomicReference;
  
  import com.aliyun.odps.conf.Configurable;
  import com.aliyun.odps.conf.Configuration;
  
  /**
   * {@link MapWritable} 和 {@link SortedMapWritable} 的基类。
   *
   * 在一个map实例中，能够添加的{@link Writable}的类型最多是127。
   */
  public abstract class AbstractMapWritable implements Writable, Configurable {
  
    private AtomicReference<Configuration> conf;
  
    /* Class to id mappings */
    Map<Class, Byte> classToIdMap = new ConcurrentHashMap<Class, Byte>();
  
    /* Id to Class mappings */
    Map<Byte, Class> idToClassMap = new ConcurrentHashMap<Byte, Class>();
  
    /* The number of new classes (those not established by the constructor) */
    private volatile byte newClasses = 0;
  
    /**
     * @return 已添加Class的种类数
     */
    byte getNewClasses() {
      return newClasses;
    }
  
    /**
     * Used to add "predefined" classes and by Writable to copy "new" classes.
     */
    private synchronized void addToMap(Class clazz, byte id) {
      if (classToIdMap.containsKey(clazz)) {
        byte b = classToIdMap.get(clazz);
        if (b != id) {
          throw new IllegalArgumentException("Class " + clazz.getName()
                                             + " already registered but maps to " + b + " and not "
                                             + id);
        }
      }
      if (idToClassMap.containsKey(id)) {
        Class c = idToClassMap.get(id);
        if (!c.equals(clazz)) {
          throw new IllegalArgumentException("Id " + id + " exists but maps to "
                                             + c.getName() + " and not " + clazz.getName());
        }
      }
      classToIdMap.put(clazz, id);
      idToClassMap.put(id, clazz);
    }
  
    /**
     * Add a Class to the maps if it is not already present.
     */
    protected synchronized void addToMap(Class clazz) {
      if (classToIdMap.containsKey(clazz)) {
        return;
      }
      if (newClasses + 1 > Byte.MAX_VALUE) {
        throw new IndexOutOfBoundsException("adding an additional class would"
                                            + " exceed the maximum number allowed");
      }
      byte id = ++newClasses;
      addToMap(clazz, id);
    }
  
    /**
     * @return the Class class for the specified id
     */
    protected Class getClass(byte id) {
      return idToClassMap.get(id);
    }
  
    /**
     * @return the id for the specified Class
     */
    protected byte getId(Class clazz) {
      return classToIdMap.containsKey(clazz) ? classToIdMap.get(clazz) : -1;
    }
  
    /**
     * Used by child copy constructors.
     */
    protected synchronized void copy(Writable other) {
      if (other != null) {
        try {
          DataOutputBuffer out = new DataOutputBuffer();
          other.write(out);
          DataInputBuffer in = new DataInputBuffer();
          in.reset(out.getData(), out.getLength());
          readFields(in);
  
        } catch (IOException e) {
          throw new IllegalArgumentException("map cannot be copied: "
                                             + e.getMessage());
        }
  
      } else {
        throw new IllegalArgumentException("source map cannot be null");
      }
    }
  
    /**
     * constructor.
     */
    protected AbstractMapWritable() {
      this.conf = new AtomicReference<Configuration>();
  
      addToMap(BooleanWritable.class,
               Byte.valueOf(Integer.valueOf(-126).byteValue()));
      addToMap(BytesWritable.class,
               Byte.valueOf(Integer.valueOf(-125).byteValue()));
      addToMap(DatetimeWritable.class,
               Byte.valueOf(Integer.valueOf(-124).byteValue()));
      addToMap(DoubleWritable.class,
               Byte.valueOf(Integer.valueOf(-123).byteValue()));
      addToMap(IntWritable.class, Byte.valueOf(Integer.valueOf(-122).byteValue()));
      addToMap(LongWritable.class,
               Byte.valueOf(Integer.valueOf(-121).byteValue()));
      addToMap(MapWritable.class, Byte.valueOf(Integer.valueOf(-120).byteValue()));
      addToMap(NullWritable.class,
               Byte.valueOf(Integer.valueOf(-119).byteValue()));
      addToMap(SortedMapWritable.class,
               Byte.valueOf(Integer.valueOf(-118).byteValue()));
      addToMap(Text.class, Byte.valueOf(Integer.valueOf(-117).byteValue()));
      addToMap(Tuple.class, Byte.valueOf(Integer.valueOf(-116).byteValue()));
    }
  
    /**
     * @return the conf
     */
    @Override
    public Configuration getConf() {
      return conf.get();
    }
  
    /**
     * @param conf
     *     the conf to set
     */
    @Override
    public void setConf(Configuration conf) {
      this.conf.set(conf);
    }
  
    @Override
    public void write(DataOutput out) throws IOException {
  
      // First write out the size of the class table and any classes that are
      // "unknown" classes
  
      out.writeByte(newClasses);
  
      for (byte i = 1; i <= newClasses; i++) {
        out.writeByte(i);
        out.writeUTF(getClass(i).getName());
      }
    }
  
    @Override
    public void readFields(DataInput in) throws IOException {
  
      // Get the number of "unknown" classes
  
      newClasses = in.readByte();
  
      // Then read in the class names and add them to our tables
  
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      for (int i = 0; i < newClasses; i++) {
        byte id = in.readByte();
        String className = in.readUTF();
        try {
          if (classLoader != null) {
            addToMap(Class.forName(className, false, classLoader), id);
          } else {
            addToMap(Class.forName(className), id);
          }
        } catch (ClassNotFoundException e) {
          throw new IOException("can't find class: " + className + " because "
                                + e.getMessage());
        }
      }
    }
  }
  