Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.protostream.impl;
  
 
 import java.util.Map;

Author(s):
anistor@redhat.com
Since:
1.0
 
 public final class SerializationContextImpl implements SerializationContext {
 
    private static final Log log = Log.LogFactory.getLog(SerializationContextImpl.class);
 
 
    private final Lock readLock = .readLock();
 
    private final Lock writeLock = .writeLock();
 
    private final Configuration configuration;
 
    private final DescriptorParser parser;
 
    private final Map<StringFileDescriptorfileDescriptors = new HashMap<StringFileDescriptor>();
 
    private final Map<IntegerStringtypeIds = new HashMap<IntegerString>();
 
 
 
 
    public SerializationContextImpl(Configuration configuration) {
       if (configuration == null) {
          throw new IllegalArgumentException("configuration cannot be null");
       }
       this. = configuration;
        = new SquareProtoParser(configuration);
    }
 
    @Override
    public Configuration getConfiguration() {
       return ;
    }
 
       .lock();
       try {
          return new HashMap<StringFileDescriptor>();
       } finally {
          .unlock();
       }
    }
 
    @Override
       if (.isDebugEnabled()) {
          .debugf("Registering proto files : %s"source.getFileDescriptors().keySet());
       }
       Map<StringFileDescriptorfileDescriptorMap = .parse(source);
       .lock();
       try {
          // unregister all types from the files that are being overwritten
          for (String fileName : fileDescriptorMap.keySet()) {
             FileDescriptor oldFileDescriptor = .get(fileName);
             if (oldFileDescriptor != null) {
                unregisterFileDescriptorTypes(oldFileDescriptor);
             }
          }
          .putAll(fileDescriptorMap);
          // resolve imports and types
          for (FileDescriptor fileDescriptor : .values()) {
             if (fileDescriptor.resolveDependencies(source.getProgressCallback(), )) {
                registerFileDescriptor(fileDescriptor);
             }
          }
          // clear errors and leave in unresolved state whatever could not be resolved
          for (FileDescriptor fileDescriptor : .values()) {
            fileDescriptor.clearErrors();
         }
      } finally {
         .unlock();
      }
   }
   public void unregisterProtoFile(String fileName) {
      .debugf("Unregistering proto file : %s"fileName);
      .lock();
      try {
         FileDescriptor fileDescriptor = .get(fileName);
         if (fileDescriptor != null) {
            .remove(fileDescriptor.getName());
            unregisterFileDescriptorTypes(fileDescriptor);
         }
      } finally {
         .unlock();
      }
   }
   @GuardedBy("writeLock")
   private void registerFileDescriptor(FileDescriptor fileDescriptor) {
      if (.isDebugEnabled()) {
         .debugf("Registering file descriptor : fileName=%s types=%s"fileDescriptor.getName(), fileDescriptor.getTypes().keySet());
      }
      Map<IntegerStringnewTypeIds = new HashMap<IntegerString>();
      for (Map.Entry<StringGenericDescriptore : fileDescriptor.getTypes().entrySet()) {
         Integer typeId = e.getValue().getTypeId();
         if (typeId != null) {
            String fullName = e.getKey();
            String existing = .get(typeId);
            if (existing != null && !existing.equals(fullName)) {
               GenericDescriptor x = fileDescriptor.getTypes().get(existing);
               if (x == null || typeId.equals(x.getTypeId())) {
                  throw new IllegalArgumentException("Duplicate type id " + typeId + " for type " + fullName + ". Already used by " + existing);
               }
            }
            existing = newTypeIds.get(typeId);
            if (existing != null) {
               throw new IllegalArgumentException("Duplicate type id " + typeId + " for type " + fullName + ". Already used by " + existing);
            }
            newTypeIds.put(typeIdfullName);
         }
      }
      .put(fileDescriptor.getName(), fileDescriptor);
      .putAll(fileDescriptor.getTypes());
      .putAll(newTypeIds);
   }
   @GuardedBy("writeLock")
   private void unregisterFileDescriptorTypes(FileDescriptor fileDescriptor) {
      for (GenericDescriptor d : fileDescriptor.getTypes().values()) {
         Integer typeId = d.getTypeId();
         if (typeId != null) {
            .remove(typeId);
         }
      }
      .keySet().removeAll(fileDescriptor.getTypes().keySet());
      for (FileDescriptor fd : fileDescriptor.getDependants().values()) {
         fd.markUnresolved();
         unregisterFileDescriptorTypes(fd);
      }
   }
   public Descriptor getMessageDescriptor(String fullName) {
      .lock();
      try {
         GenericDescriptor descriptor = .get(fullName);
         if (descriptor == null) {
            throw new IllegalArgumentException("Message descriptor not found : " + fullName);
         }
         if (!(descriptor instanceof Descriptor)) {
            throw new IllegalArgumentException(fullName + " is not a message type");
         }
         return (Descriptordescriptor;
      } finally {
         .unlock();
      }
   }
   public EnumDescriptor getEnumDescriptor(String fullName) {
      .lock();
      try {
         GenericDescriptor descriptor = .get(fullName);
         if (descriptor == null) {
            throw new IllegalArgumentException("Enum descriptor not found : " + fullName);
         }
         if (!(descriptor instanceof EnumDescriptor)) {
            throw new IllegalArgumentException(fullName + " is not an enum type");
         }
         return (EnumDescriptordescriptor;
      } finally {
         .unlock();
      }
   }
   public <T> void registerMarshaller(BaseMarshaller<T> marshaller) {
      // we try to validate first that a message descriptor exists
      BaseMarshallerDelegate marshallerDelegate;
      if (marshaller instanceof EnumMarshaller) {
         if (!marshaller.getJavaClass().isEnum()) {
            throw new IllegalArgumentException("Invalid enum marshaller (the produced class is not an Enum) : " + marshaller);
         }
         EnumDescriptor enumDescriptor = getEnumDescriptor(marshaller.getTypeName());
         marshallerDelegate = new EnumMarshallerDelegate((EnumMarshallermarshallerenumDescriptor);
      } else if (marshaller instanceof RawProtobufMarshaller) {
         marshallerDelegate = new RawProtobufMarshallerDelegate(this, (RawProtobufMarshallermarshaller);
      } else {
         Descriptor messageDescriptor = getMessageDescriptor(marshaller.getTypeName());
         marshallerDelegate = new MessageMarshallerDelegate(this, (MessageMarshallermarshallermessageDescriptor);
      }
      .put(marshaller.getTypeName(), marshallerDelegate);
      .put(marshaller.getJavaClass(), marshallerDelegate);
   }
   public boolean canMarshall(Class clazz) {
      return .containsKey(clazz);
   }
   public boolean canMarshall(String descriptorFullName) {
      .lock();
      try {
         return .containsKey(descriptorFullName);
         //TODO the correct implementation should be: return marshallersByName.containsKey(descriptorFullName);
      } finally {
         .unlock();
      }
   }
   public <T> BaseMarshaller<T> getMarshaller(String descriptorFullName) {
      return this.<T>getMarshallerDelegate(descriptorFullName).getMarshaller();
   }
   public <T> BaseMarshaller<T> getMarshaller(Class<T> clazz) {
      return getMarshallerDelegate(clazz).getMarshaller();
   }
   public <T> BaseMarshallerDelegate<T> getMarshallerDelegate(String descriptorFullName) {
      BaseMarshallerDelegate<T> marshallerDelegate = (BaseMarshallerDelegate<T>) .get(descriptorFullName);
      if (marshallerDelegate == null) {
         throw new IllegalArgumentException("No marshaller registered for " + descriptorFullName);
      }
      return marshallerDelegate;
   }
   public <T> BaseMarshallerDelegate<T> getMarshallerDelegate(Class<T> clazz) {
      BaseMarshallerDelegate<T> marshallerDelegate = (BaseMarshallerDelegate<T>) .get(clazz);
      if (marshallerDelegate == null) {
         throw new IllegalArgumentException("No marshaller registered for " + clazz);
      }
      return marshallerDelegate;
   }
   public String getTypeNameById(Integer typeId) {
      .lock();
      try {
         String descriptorFullName = .get(typeId);
         if (descriptorFullName == null) {
            throw new IllegalArgumentException("Unknown type id : " + typeId);
         }
         return descriptorFullName;
      } finally {
         .unlock();
      }
   }
   public Integer getTypeIdByName(String descriptorFullName) {
      .lock();
      try {
         GenericDescriptor descriptor = .get(descriptorFullName);
         if (descriptor == null) {
            throw new IllegalArgumentException("Unknown type name : " + descriptorFullName);
         }
         return descriptor.getTypeId();
      } finally {
         .unlock();
      }
   }
New to GrepCode? Check out our FAQ X