Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.helix;
  
  /*
   * 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.
  */
 
 import java.util.List;
 import java.util.Map;
 
A wrapper class for ZNRecord. Used as a base class for IdealState, CurrentState, etc.
 
 public class HelixProperty {
   private static Logger LOG = Logger.getLogger(HelixProperty.class);
 
   public enum HelixPropertyAttribute {
     BUCKET_SIZE,
     BATCH_MESSAGE_MODE
   }
 
   protected final ZNRecord _record;

  
Initialize the property with an identifier

Parameters:
id
 
   public HelixProperty(String id) {
      = new ZNRecord(id);
   }

  
Initialize the property with an existing ZNRecord

Parameters:
record
 
   public HelixProperty(ZNRecord record) {
      = new ZNRecord(record);
   }

  
Initialize the property by copying from another property

Parameters:
property
 
   public HelixProperty(HelixProperty property) {
      = new ZNRecord(property.getRecord());
   }

  
Get the property identifier

Returns:
the property id
 
   public final String getId() {
     return .getId();
   }

  
Get the backing ZNRecord

Returns:
ZNRecord object associated with this property
 
   public final ZNRecord getRecord() {
     return ;
   }

  
Set the changes to the backing ZNRecord

Parameters:
deltaList list of ZNRecord updates to be made
 
   public final void setDeltaList(List<ZNRecordDeltadeltaList) {
     .setDeltaList(deltaList);
   }
 
   @Override
   public String toString() {
     return .toString();
   }

  
Get the size of buckets defined

Returns:
the bucket size, or 0 if not defined
  public int getBucketSize() {
    int bucketSize = 0;
    if (bucketSizeStr != null) {
      try {
        bucketSize = Integer.parseInt(bucketSizeStr);
      } catch (NumberFormatException e) {
        // OK
      }
    }
    return bucketSize;
  }

  
Set the size of buckets defined

Parameters:
bucketSize the bucket size (will default to 0 if negative)
  public void setBucketSize(int bucketSize) {
    if (bucketSize <= 0)
      bucketSize = 0;
  }

  
static method that converts ZNRecord to an instance that subclasses HelixProperty

Parameters:
clazz subclass of HelixProperty
record the ZNRecord describing the property
Returns:
typed instance corresponding to the record, or null if conversion fails
  public static <T extends HelixProperty> T convertToTypedInstance(Class<T> clazzZNRecord record) {
    if (record == null) {
      return null;
    }
    try {
      Constructor<T> constructor = clazz.getConstructor(new Class[] {
        ZNRecord.class
      });
      return constructor.newInstance(record);
    } catch (Exception e) {
      .error("Exception convert znrecord: " + record + " to class: " + clazze);
    }
    return null;
  }

  
Convert a collection of records to typed properties

Parameters:
clazz Subclass of HelixProperty
records the ZNRecords describing the property
Returns:
list of typed instances for which the conversion succeeded, or null if records is null
  public static <T extends HelixPropertyList<T> convertToTypedList(Class<T> clazz,
      Collection<ZNRecordrecords) {
    if (records == null) {
      return null;
    }
    List<T> decorators = new ArrayList<T>();
    for (ZNRecord record : records) {
      T decorator = HelixProperty.convertToTypedInstance(clazzrecord);
      if (decorator != null) {
        decorators.add(decorator);
      }
    }
    return decorators;
  }

  
Converts a list of records to a map of the record identifier to typed properties

Parameters:
records the ZNRecords to convert
Returns:
id --> HelixProperty subclass map
  public static <T extends HelixPropertyMap<String, T> convertListToMap(List<T> records) {
    if (records == null) {
      return Collections.emptyMap();
    }
    Map<String, T> decorators = new HashMap<String, T>();
    for (T record : records) {
      decorators.put(record.getId(), record);
    }
    return decorators;
  }

  
Convert typed properties to a list of records

Parameters:
typedInstances objects subclassing HelixProperty
Returns:
a list of ZNRecord objects
  public static <T extends HelixPropertyList<ZNRecordconvertToList(List<T> typedInstances) {
    if (typedInstances == null) {
      return Collections.emptyList();
    }
    List<ZNRecordrecords = new ArrayList<ZNRecord>();
    for (T typedInstance : typedInstances) {
      records.add(typedInstance.getRecord());
    }
    return records;
  }

  
Change the state of batch messaging

Parameters:
enable true to enable, false to disable
  public void setBatchMessageMode(boolean enable) {
  }

  
Get the state of batch messaging

Returns:
true if enabled, false if disabled
  public boolean getBatchMessageMode() {
    if (enableStr == null) {
      return false;
    }
    try {
      return Boolean.parseBoolean(enableStr.toLowerCase());
    } catch (Exception e) {
      return false;
    }
  }

  
Add namespaced configuration properties to this property

Parameters:
namespacedConfig namespaced properties
  public void addNamespacedConfig(NamespacedConfig namespacedConfig) {
    NamespacedConfig.addConfigToProperty(thisnamespacedConfig);
  }

  
Get property validity

Returns:
true if valid, false if invalid
  public boolean isValid() {
    return true;
  }
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (obj instanceof HelixProperty) {
      HelixProperty that = (HelixPropertyobj;
      if (that.getRecord() != null) {
        return that.getRecord().equals(this.getRecord());
      }
    }
    return false;
  }
New to GrepCode? Check out our FAQ X