sjero.net Git - linphone/blob - p2pproxy/dependencies-src/jxse-src-2.5/impl/src/net/jxta/impl/id/UUID/ModuleClassID.java

   1 /*
   2  * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
   3  *
   4  *  The Sun Project JXTA(TM) Software License
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *
  12  *  2. Redistributions in binary form must reproduce the above copyright notice,
  13  *     this list of conditions and the following disclaimer in the documentation
  14  *     and/or other materials provided with the distribution.
  15  *
  16  *  3. The end-user documentation included with the redistribution, if any, must
  17  *     include the following acknowledgment: "This product includes software
  18  *     developed by Sun Microsystems, Inc. for JXTA(TM) technology."
  19  *     Alternately, this acknowledgment may appear in the software itself, if
  20  *     and wherever such third-party acknowledgments normally appear.
  21  *
  22  *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
  23  *     not be used to endorse or promote products derived from this software
  24  *     without prior written permission. For written permission, please contact
  25  *     Project JXTA at http://www.jxta.org.
  26  *
  27  *  5. Products derived from this software may not be called "JXTA", nor may
  28  *     "JXTA" appear in their name, without prior written permission of Sun.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
  31  *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  32  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN
  33  *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  36  *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  37  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  38  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  39  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United
  42  *  States and other countries.
  43  *
  44  *  Please see the license information page at :
  45  *  <http://www.jxta.org/project/www/license.html> for instructions on use of
  46  *  the license in source files.
  47  *
  48  *  ====================================================================
  49  *
  50  *  This software consists of voluntary contributions made by many individuals
  51  *  on behalf of Project JXTA. For more information on Project JXTA, please see
  52  *  http://www.jxta.org.
  53  *
  54  *  This license is based on the BSD license adopted by the Apache Foundation.
  55  */
  56
  57 package net.jxta.impl.id.UUID;
  58
  59
  60 import java.util.logging.Logger;
  61 import java.util.logging.Level;
  62 import net.jxta.logging.Logging;
  63
  64
  65 /**
  66  *  An implementation of the {@link net.jxta.platform.ModuleClassID} ID Type.
  67  */
  68 public class ModuleClassID extends net.jxta.platform.ModuleClassID {
  69
  70     /**
  71      *  Location of the class id
  72      */
  73     private final static int moduleClassIdOffset = 0;
  74
  75     /**
  76      *  Location of the role id
  77      */
  78     private final static int moduleRoleIdOffset = moduleClassIdOffset + IDFormat.uuidSize;
  79
  80     /**
  81      *  location of the start of the pad space
  82      */
  83     private final static int padOffset = ModuleClassID.moduleRoleIdOffset + IDFormat.uuidSize;
  84
  85     /**
  86      *  size of the unused space
  87      */
  88     private final static int padSize = IDFormat.flagsOffset - ModuleClassID.padOffset;
  89
  90     /**
  91      *  The id data
  92      */
  93     protected IDBytes id;
  94
  95     /**
  96      * Constructor.
  97      * Initializes contents from provided ID.
  98      *
  99      * @param id    the ID data
 100      */
 101     protected ModuleClassID(IDBytes id) {
 102         super();
 103         this.id = id;
 104     }
 105
 106     /**
 107      * Constructor.
 108      * Creates a ModuleClassID in a given class, with a given class unique id.
 109      * A UUID of a class and another UUID are provided.
 110      *
 111      * @param classUUID    the class to which this will belong.
 112      * @param roleUUID     the unique id of this role in that class.
 113      */
 114     protected ModuleClassID(UUID classUUID, UUID roleUUID) {
 115         super();
 116         id = new IDBytes(IDFormat.flagModuleClassID);
 117
 118         id.longIntoBytes(ModuleClassID.moduleClassIdOffset, classUUID.getMostSignificantBits());
 119         id.longIntoBytes(ModuleClassID.moduleClassIdOffset + 8, classUUID.getLeastSignificantBits());
 120
 121         id.longIntoBytes(ModuleClassID.moduleRoleIdOffset, roleUUID.getMostSignificantBits());
 122         id.longIntoBytes(ModuleClassID.moduleRoleIdOffset + 8, roleUUID.getLeastSignificantBits());
 123     }
 124
 125     /**
 126      *  See {@link net.jxta.id.IDFactory.Instantiator#newModuleClassID()}.
 127      *
 128      *  <p/>A new class UUID is created. The role ID is left null. This is the
 129      *  only way to create a new class without supplying a new UUID explicitly.
 130      *
 131      *  <p/>Note that a null role is just as valid as any other, it just has a
 132      *  shorter string representation. So it is not mandatory to create a new
 133      *  role in a new class.
 134      */
 135     public ModuleClassID() {
 136         this(UUIDFactory.newUUID(), new UUID(0L, 0L));
 137     }
 138
 139     /**
 140      *  See {@link net.jxta.id.IDFactory.Instantiator#newModuleClassID(net.jxta.platform.ModuleClassID)}.
 141      */
 142     public ModuleClassID(ModuleClassID classID) {
 143         this(classID.getClassUUID(), UUIDFactory.newUUID());
 144     }
 145
 146     /**
 147      *  {@inheritDoc}
 148      */
 149     @Override
 150     public boolean equals(Object target) {
 151         if (this == target) {
 152             return true;
 153         }
 154
 155         if (target instanceof ModuleClassID) {
 156             ModuleClassID mcidTarget = (ModuleClassID) target;
 157
 158             return id.equals(mcidTarget.id);
 159         } else {
 160             return false;
 161         }
 162     }
 163
 164     /**
 165      *  {@inheritDoc}
 166      */
 167     @Override
 168     public int hashCode() {
 169         return id.hashCode();
 170     }
 171
 172     /**
 173      *  {@inheritDoc}
 174      */
 175     @Override
 176     public String getIDFormat() {
 177         return IDFormat.INSTANTIATOR.getSupportedIDFormat();
 178     }
 179
 180     /**
 181      *  {@inheritDoc}
 182      */
 183     @Override
 184     public Object getUniqueValue() {
 185         return getIDFormat() + "-" + (String) id.getUniqueValue();
 186     }
 187
 188     /**
 189      *  {@inheritDoc}
 190      */
 191     @Override
 192     public net.jxta.platform.ModuleClassID getBaseClass() {
 193         return new ModuleClassID(getClassUUID(), new UUID(0L, 0L));
 194     }
 195
 196     /**
 197      *  {@inheritDoc}
 198      */
 199     @Override
 200     public boolean isOfSameBaseClass(net.jxta.platform.ModuleClassID classId) {
 201         return getClassUUID().equals(((ModuleClassID) classId).getClassUUID());
 202     }
 203
 204     /**
 205      *  {@inheritDoc}
 206      */
 207     @Override
 208     public boolean isOfSameBaseClass(net.jxta.platform.ModuleSpecID specId) {
 209         return getClassUUID().equals(((ModuleSpecID) specId).getClassUUID());
 210     }
 211
 212     /**
 213      * get the class' unique id
 214      *
 215      * @return UUID module class' unique id
 216      */
 217     protected UUID getClassUUID() {
 218         UUID result = new UUID(id.bytesIntoLong(ModuleClassID.moduleClassIdOffset)
 219                 ,
 220                 id.bytesIntoLong(ModuleClassID.moduleClassIdOffset + 8));
 221
 222         return result;
 223     }
 224
 225     /**
 226      * get the role unique id
 227      *
 228      * @return UUID module role unique id
 229      */
 230     protected UUID getRoleUUID() {
 231         UUID result = new UUID(id.bytesIntoLong(ModuleClassID.moduleRoleIdOffset)
 232                 ,
 233                 id.bytesIntoLong(ModuleClassID.moduleRoleIdOffset + 8));
 234
 235         return result;
 236     }
 237 }