private[storage] def padTweetIdStr()

in tweetypie/common/src/scala/com/twitter/tweetypie/storage/TweetKey.scala [50:163]
86 lines of code
27 McCabe index (conditional complexity)

  private[storage] def padTweetIdStr(tweetId: Long): String = TweetIdFormatStr.format(tweetId)
  private[storage] def padFieldIdStr(fieldId: Short): String = FieldIdFormatStr.format(fieldId)

  def coreFieldsKey(tweetId: TweetId): TweetKey = TweetKey(tweetId, LKey.CoreFieldsKey)
  def hardDeletionStateKey(tweetId: TweetId): TweetKey =
    TweetKey(tweetId, LKey.HardDeletionStateKey)
  def softDeletionStateKey(tweetId: TweetId): TweetKey =
    TweetKey(tweetId, LKey.SoftDeletionStateKey)
  def bounceDeletionStateKey(tweetId: TweetId): TweetKey =
    TweetKey(tweetId, LKey.BounceDeletionStateKey)
  def unDeletionStateKey(tweetId: TweetId): TweetKey = TweetKey(tweetId, LKey.UnDeletionStateKey)
  def forceAddedStateKey(tweetId: TweetId): TweetKey = TweetKey(tweetId, LKey.ForceAddedStateKey)
  def scrubbedGeoFieldKey(tweetId: TweetId): TweetKey = TweetKey(tweetId, LKey.ScrubbedGeoFieldKey)
  def fieldKey(tweetId: TweetId, fieldId: FieldId): TweetKey =
    TweetKey(tweetId, LKey.FieldKey(fieldId))
  def internalFieldsKey(tweetId: TweetId, fieldId: FieldId): TweetKey =
    TweetKey(tweetId, LKey.InternalFieldsKey(fieldId))
  def additionalFieldsKey(tweetId: TweetId, fieldId: FieldId): TweetKey =
    TweetKey(tweetId, LKey.AdditionalFieldsKey(fieldId))
  def scrubbedFieldKey(tweetId: TweetId, fieldId: FieldId): TweetKey =
    TweetKey(tweetId, LKey.ScrubbedFieldKey(fieldId))

  // AllFieldsKeyPrefix:       fields
  // CoreFieldsKey:            fields/internal/1  (Stores subset of StoredTweet fields which are
  //                             "packed" into a single CoreFields record)
  // HardDeletionStateKey:     metadata/delete_state
  // SoftDeletionStateKey:     metadata/soft_delete_state
  // BounceDeletionStateKey:   metadata/bounce_delete_state
  // UnDeletionStateKey:       metadata/undelete_state
  // ForceAddedStateKey:       metadata/force_added_state
  // FieldKey:                 fields/<group_name>/<padded_field_id> (where <group_name>
  //                             is 'internal' for field ids < 100 and 'external' for all other
  //                             fields ids)
  // InternalFieldsKeyPrefix:  fields/internal
  // PKey:                     <empty string>
  // ScrubbedFieldKey:         metadata/scrubbed_fields/<padded_field_id>
  // ScrubbedFieldKeyPrefix:   metadata/scrubbed_fields
  sealed abstract class LKey(override val toString: String)
  object LKey {
    private val HardDeletionRecordLiteral = "delete_state"
    private val SoftDeletionRecordLiteral = "soft_delete_state"
    private val BounceDeletionRecordLiteral = "bounce_delete_state"
    private val UnDeletionRecordLiteral = "undelete_state"
    private val ForceAddRecordLiteral = "force_added_state"
    private val ScrubbedFieldsGroup = "scrubbed_fields"
    private val InternalFieldsGroup = "internal"
    private val ExternalFieldsGroup = "external"
    private val MetadataCategory = "metadata"
    private val FieldsCategory = "fields"
    private val InternalFieldsKeyPrefix = s"$FieldsCategory/$InternalFieldsGroup/"
    private val ExternalFieldsKeyPrefix = s"$FieldsCategory/$ExternalFieldsGroup/"
    private val ScrubbedFieldsKeyPrefix = s"$MetadataCategory/$ScrubbedFieldsGroup/"

    sealed abstract class MetadataKey(metadataType: String)
        extends LKey(s"$MetadataCategory/$metadataType")
    sealed abstract class StateKey(stateType: String) extends MetadataKey(stateType)
    case object HardDeletionStateKey extends StateKey(s"$HardDeletionRecordLiteral")
    case object SoftDeletionStateKey extends StateKey(s"$SoftDeletionRecordLiteral")
    case object BounceDeletionStateKey extends StateKey(s"$BounceDeletionRecordLiteral")
    case object UnDeletionStateKey extends StateKey(s"$UnDeletionRecordLiteral")
    case object ForceAddedStateKey extends StateKey(s"$ForceAddRecordLiteral")

    case class ScrubbedFieldKey(fieldId: FieldId)
        extends MetadataKey(s"$ScrubbedFieldsGroup/${padFieldIdStr(fieldId)}")
    val ScrubbedGeoFieldKey: LKey.ScrubbedFieldKey = ScrubbedFieldKey(TweetFields.geoFieldId)

    /**
     * LKey that has one of many possible fields id. This generalize over
     * internal and additional fields key.
     */
    sealed abstract class FieldKey(prefix: String) extends LKey(toString) {
      def fieldId: FieldId
      override val toString: String = prefix + padFieldIdStr(fieldId)
    }
    object FieldKey {
      def apply(fieldId: FieldId): FieldKey =
        fieldId match {
          case id if id < TweetFields.firstAdditionalFieldId => InternalFieldsKey(fieldId)
          case _ => AdditionalFieldsKey(fieldId)
        }
    }

    case class InternalFieldsKey(fieldId: FieldId) extends FieldKey(InternalFieldsKeyPrefix) {
      assert(fieldId < TweetFields.firstAdditionalFieldId)
    }
    case class AdditionalFieldsKey(fieldId: FieldId) extends FieldKey(ExternalFieldsKeyPrefix) {
      assert(fieldId >= TweetFields.firstAdditionalFieldId)
    }
    val CoreFieldsKey: LKey.InternalFieldsKey = InternalFieldsKey(TweetFields.rootCoreFieldId)

    case class Unknown private (str: String) extends LKey(str)

    def fromString(str: String): LKey = {
      def extractFieldId(prefix: String): FieldId =
        str.slice(prefix.length, str.length).toShort

      str match {
        case CoreFieldsKey.toString => CoreFieldsKey
        case HardDeletionStateKey.toString => HardDeletionStateKey
        case SoftDeletionStateKey.toString => SoftDeletionStateKey
        case BounceDeletionStateKey.toString => BounceDeletionStateKey
        case UnDeletionStateKey.toString => UnDeletionStateKey
        case ForceAddedStateKey.toString => ForceAddedStateKey
        case ScrubbedGeoFieldKey.toString => ScrubbedGeoFieldKey
        case _ if str.startsWith(InternalFieldsKeyPrefix) =>
          InternalFieldsKey(extractFieldId(InternalFieldsKeyPrefix))
        case _ if str.startsWith(ExternalFieldsKeyPrefix) =>
          AdditionalFieldsKey(extractFieldId(ExternalFieldsKeyPrefix))
        case _ if str.startsWith(ScrubbedFieldsKeyPrefix) =>
          ScrubbedFieldKey(extractFieldId(ScrubbedFieldsKeyPrefix))
        case _ => Unknown(str)
      }
    }
  }