Accelerated Piano Adventures: For the Older Beginner SightReading Book 1 teaches students the basics of sight reading. Students will learn to recognize individual notes and note patterns (both rhythmic and melodic) through studying musical variations drawn from Bach, Beethoven, Brahms, Mozart, as well as traditional folk songs. Students will learn to sight-read music that includes eighth note rhythms, all the notes of a grand staff, intervals of 2nd, 3rd, 4th, 5th, and octave, C and G five-finger melodies, and I and V7 chords in the keys of C and G.
The Piano Adventures method teaches students through a step-by -step approach with constant review. This book is organized into sets of five daily exercises based upon the (not-included and sold-separately) lesson book. Students are to play one exercise a day for one set completed per week. 95 pages, softcover.


text:
Tigers have `average' first day in full gear
Tom Schad
This morning's Memphis football practice started with touchdown passes on the first two plays of team drills. It ended with the offense dragging, and the defense responding, but neither unit playing up to coach Mike Norvell's standards.
Overall, he described it as an 'average' day.
'Definitely not a championship practice by any stretch of the imagination,' Norvell said, 'but it was a good day.'
It was the team's first practice in full pads, so there was a bit more contact than previous days. The staff also introduced more situational drills, including overtime periods toward the end of the session.
Anthony Miller caught a pass on a slant route and sprinted to the end zone on the first play of team drills, and Phil Mayhue caught a deep pass for a score on the second play. But Norvell was not especially pleased with the offense's performance from that point forward. While the defense maintained its intensity throughout the session, he said the offense withered late.
'We put them through a lot of different situations,' Norvell said. 'We got some real series work, moving the football, got a little overtime period. Just trying to really teach guys and put them in a place that they'll see here throughout the season.
'Offensively, I thought we really dragged there late. Nowhere near what our standard needs to be. We've got to respond to it.'
Gentry standing out
Asked which players have stood out through the first five days of fall camp, Norvell mentioned, among others, sophomore defensive tackle Jared Gentry.
'Jared's a guy that we've challenged. Played some last year as a true freshman. Just an enormous human being,' Norvell said. 'And I think he did a great job this summer getting himself in shape. He's really kind of put himself in a great position to help us at a higher level this year, so I've really been pleased with what I've seen from him.'
Gentry made a couple of nice plays in team drills, bursting through the second-team offensive line to disrupt the backfield. He's still listed at 325 pounds but looks a bit slimmer than a year ago. And from watching him in positional drills, he also just looks a bit faster in his movements.
Gentry may not be able to supplant redshirt senior Donald Pennington as the team's starting defensive tackle, but he will certainly play a role in the rotation up front.
'Just put your head down and work. That's what I've been trying to do.' -- Redshirt freshman quarterback Brady Davis, on his mentality in camp. Norvell has yet to name a starting QB, though Riley Ferguson remains the frontrunner.
-- On the first play of an overtime situation, Doroland Dorceus zig-zagged through the defense, breaking several arm tackles, and carried a few defenders into the end zone. Certainly the most impressive run of the day.
-- A few newcomers had nice individual plays as well: Thomas Pickens corralled a deflected pass with one hand for an interception, and John 'Pop' Williams showed off his agility on a short pass, crisscrossing to the opposite side of the field while navigating would-be tacklers along the way.
-- A previously-unmentioned personnel note: I saw offensive lineman Zach Collins working off to the side this morning. He appears to be recovering from an injury. Jackson Dillon, meanwhile, participated in team drills and is continuing to work his way back. Will have more on him, and his role, online tomorrow morning.
-- NFL scouts from three teams were in attendance at practice today. A fourth scout was on hand earlier this week.
-- Our first 2016 installment of 'Three Questions' features freshman running back Patrick Taylor Jr., who describes himself as 'a smiler.'
-- Anthony Miller, whom Riley Ferguson called 'probably the best (receiver) I've ever thrown to,' is set to receive ample opportunities in Norvell's offense.
-- Yesterday's practice report, featuring Norvell's reaction and a note about junior-college transfer (and former Tennessee signee) Kyle Oliver.
-- Will the Big 12 expand by two teams? Four? Phil explored that question in Sunday's paper.

redpajama_set_name: RedPajamaCommonCrawl


text:
$: << 'RspecTests/Generated/http_infrastructure'
$: << 'RspecTests'

require 'rspec'
require 'http_infrastructure.rb'
require 'helper'

module HttpInfrastructureModule
  include HttpInfrastructureModule::Models

describe 'HttpInfrastructure' do

  before(:all) do
    @base_url = ENV['StubServerURI']

    dummyToken = 'dummy12321343423'
    @credentials = MsRest::TokenCredentials.new(dummyToken)

    client = AutoRestHttpInfrastructureTestService.new(@credentials, @base_url)
    @failure_client = HttpClientFailure.new(client)
    @redirect_client = HttpRedirects.new(client)
    @retry_client = HttpRetry.new(client)
    @server_fail_client = HttpServerFailure.new(client)
    @success_client = HttpSuccess.new(client)
    @multiple_resp_client = MultipleResponses.new(client)
  end

  it 'should create test service' do
    expect { AutoRestHttpInfrastructureTestService.new(@credentials, @base_url) }.not_to raise_error
  end

  context HttpClientFailure do
    it 'should send head 400' do
      expect { @failure_client.head400_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 400' do
      expect { @failure_client.get400_async().value! }.to raise_exception_with_code(400)
    end

    it 'should put 400' do
      expect { @failure_client.put400_async(true).value! }.to raise_exception_with_code(400)
    end

    it 'should patch 400' do
      expect { @failure_client.patch400_async(true).value! }.to raise_exception_with_code(400)
    end

    it 'should post 400' do
      expect { @failure_client.post400_async(true).value! }.to raise_exception_with_code(400)
    end

    it 'should delete 400' do
      expect { @failure_client.delete400_async(true).value! }.to raise_exception_with_code(400)
    end

    it 'should send head 401' do
      expect { @failure_client.head401_async().value! }.to raise_exception_with_code(401)
    end

    it 'should get 402' do
      expect { @failure_client.get402_async().value! }.to raise_exception_with_code(402)
    end

    it 'should get 403' do
      expect { @failure_client.get403_async().value! }.to raise_exception_with_code(403)
    end

    it 'should put 404' do
      expect { @failure_client.put404_async(true).value! }.to raise_exception_with_code(404)
    end

    it 'should patch 405' do
      expect { @failure_client.patch405_async(true).value! }.to raise_exception_with_code(405)
    end

    it 'should post 406' do
      expect { @failure_client.post406_async(true).value! }.to raise_exception_with_code(406)
    end

    it 'should delete 407' do
      expect { @failure_client.delete407_async(true).value! }.to raise_exception_with_code(407)
    end

    it 'should put 409' do
      expect { @failure_client.put409_async(true).value! }.to raise_exception_with_code(409)
    end

    it 'should send head 410' do
      expect { @failure_client.head410_async().value! }.to raise_exception_with_code(410)
    end

    it 'should get 411' do
      expect { @failure_client.get411_async().value! }.to raise_exception_with_code(411)
    end

    it 'should get 412' do
      expect { @failure_client.get412_async().value! }.to raise_exception_with_code(412)
    end

    it 'should put 413' do
      expect { @failure_client.put413_async(true).value! }.to raise_exception_with_code(413)
    end

    it 'should patch 414' do
      expect { @failure_client.patch414_async(true).value! }.to raise_exception_with_code(414)
    end

    it 'should post 415' do
      expect { @failure_client.post415_async(true).value! }.to raise_exception_with_code(415)
    end

    it 'should get 416' do
      expect { @failure_client.get416_async().value! }.to raise_exception_with_code(416)
    end

    it 'should delete 417' do
      expect { @failure_client.delete417_async(true).value! }.to raise_exception_with_code(417)
    end

    it 'should send head 429' do
      expect { @failure_client.head429_async().value! }.to raise_exception_with_code(429)
    end
  end

  context HttpRedirects do
    it 'should send head 300' do
      result = @redirect_client.head300_async().value!
      expect(result.response.status).to eq(300)
    end

    it 'should get 300' do
      result = @redirect_client.get300_async().value!
      expect(result.response.status).to eq(300)
      expect(result.body[0]).to eq("/http/success/get/200")
    end

    it 'should send head 301' do
      result = @redirect_client.head301_async().value!
      expect(result.response.status).to eq(301)
    end

    it 'should get 301' do
      result = @redirect_client.get301_async().value!
      expect(result.response.status).to eq(301)
    end

    it 'should put 301' do
      result = @redirect_client.put301_async(true).value!
      expect(result.response.status).to eq(301)
    end

    it 'should send head 302' do
      result = @redirect_client.head302_async().value!
      expect(result.response.status).to eq(302)
    end

    it 'should get 302' do
      result = @redirect_client.get302_async().value!
      expect(result.response.status).to eq(302)
    end

    it 'should patch 302' do
      result = @redirect_client.patch302_async(true).value!
      expect(result.response.status).to eq(302)
    end

    it 'should post 303' do
      result = @redirect_client.post303_async(true).value!
      expect(result.response.status).to eq(303)
    end

    it 'should send head 307' do
      result = @redirect_client.head307_async().value!
      expect(result.response.status).to eq(307)
    end

    it 'should get 307' do
      result = @redirect_client.get307_async().value!
      expect(result.response.status).to eq(307)
    end

    it 'should put 307' do
      result = @redirect_client.put307_async(true).value!
      expect(result.response.status).to eq(307)
    end

    it 'should patch 307' do
      result = @redirect_client.patch307_async(true).value!
      expect(result.response.status).to eq(307)
    end

    it 'should post 307' do
      result = @redirect_client.post307_async(true).value!
      expect(result.response.status).to eq(307)
    end

    it 'should delete 307' do
      result = @redirect_client.delete307_async(true).value!
      expect(result.response.status).to eq(307)
    end
  end

  context HttpRetry do
    it 'should send head 408' do
      result = @retry_client.head408_async().value!
      expect(result.response.status).to eq(200)
    end

    it 'should put 500' do
      result = @retry_client.put500_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should patch 500' do
      result = @retry_client.patch500_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should get 502' do
      result = @retry_client.get502_async().value!
      expect(result.response.status).to eq(200)
    end

    it 'should post 503' do
      result = @retry_client.post503_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should delete 503' do
      result = @retry_client.delete503_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should put 504' do
      result = @retry_client.put504_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should patch 504' do
      result = @retry_client.patch504_async(true).value!
      expect(result.response.status).to eq(200)
    end
  end

  context HttpServerFailure do
    it 'should send head 501' do
      expect { @server_fail_client.head501_async().value! }.to raise_exception_with_code(501)
    end

    it 'should send get 501' do
      expect { @server_fail_client.get501_async().value! }.to raise_exception_with_code(501)
    end

    it 'should send post 505' do
      expect { @server_fail_client.post505_async(true).value! }.to raise_exception_with_code(505)
    end

    it 'should send delete 505' do
      expect { @server_fail_client.delete505_async(true).value! }.to raise_exception_with_code(505)
    end
  end

  context HttpSuccess do
    it 'should send head 200' do
      result = @success_client.head200_async().value!
      expect(result.response.status).to eq(200)
    end

    it 'should get 200' do
      result = @success_client.get200_async().value!
      expect(result.body).to be_truthy
      expect(result.response.status).to eq(200)
    end

    it 'should put 200' do
      result = @success_client.put200_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should patch 200' do
      result = @success_client.patch200_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should post 200' do
      result = @success_client.post200_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should delete 200' do
      result = @success_client.delete200_async(true).value!
      expect(result.response.status).to eq(200)
    end

    it 'should put 201' do
      result = @success_client.put201_async(true).value!
      expect(result.response.status).to eq(201)
    end

    it 'should post 201' do
      result = @success_client.post201_async(true).value!
      expect(result.response.status).to eq(201)
    end

    it 'should put 202' do
      result = @success_client.put202_async(true).value!
      expect(result.response.status).to eq(202)
    end

    it 'should patch 202' do
      result = @success_client.patch202_async(true).value!
      expect(result.response.status).to eq(202)
    end

    it 'should post 202' do
      result = @success_client.post202_async(true).value!
      expect(result.response.status).to eq(202)
    end

    it 'should delete 202' do
      result = @success_client.delete202_async(true).value!
      expect(result.response.status).to eq(202)
    end

    it 'should send head 204' do
      result = @success_client.head204_async().value!
      expect(result.response.status).to eq(204)
    end

    it 'should put 204' do
      result = @success_client.put204_async(true).value!
      expect(result.response.status).to eq(204)
    end

    it 'should patch 204' do
      result = @success_client.patch204_async(true).value!
      expect(result.response.status).to eq(204)
    end

    it 'should post 204' do
      result = @success_client.post204_async(true).value!
      expect(result.response.status).to eq(204)
    end

    it 'should delete 204' do
      result = @success_client.delete204_async(true).value!
      expect(result.response.status).to eq(204)
    end
  end

  context MultipleResponses do
    it 'should get 200->204->200 valid' do
      result = @multiple_resp_client.get200model204no_model_default_error200valid_async().value!.response
      expect(result.status).to eq(200)
    end

    it 'should get 200->204->204 valid' do
      result = @multiple_resp_client.get200model204no_model_default_error204valid_async().value!.response
      expect(result.status).to eq(204)
    end

    it 'should get 200->204->201 invalid' do
      expect { @multiple_resp_client.get200model204no_model_default_error201invalid_async().value! }.to raise_exception_with_code(201)
    end

    it 'should get 200->204->202 none' do
      expect { @multiple_resp_client.get200model204no_model_default_error202none_async().value! }.to raise_exception_with_code(202)
    end

    it 'should get 200->204->400 valid' do
      expect { @multiple_resp_client.get200model204no_model_default_error400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200->201->200 valid' do
      result = @multiple_resp_client.get200model201model_default_error200valid_async().value!
      expect(result.response.status).to eq(200)
      expect(result.body).to be_an_instance_of(Models::A)
      expect(result.body.status_code.to_i).to eq(200)
    end

    it 'should get 200->201->201 valid' do
      result = @multiple_resp_client.get200model201model_default_error201valid_async().value!
      expect(result.response.status).to eq(201)
      expect(result.body).to be_an_instance_of(Models::B)
      expect(result.body.text_status_code).to eq("Created")
    end

    it 'should get 200->201->400 valid' do
      expect { @multiple_resp_client.get200model201model_default_error400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200->201->404->201 valid' do
      result = @multiple_resp_client.get200model_a201model_c404model_ddefault_error201valid_async().value!
      expect(result.response.status).to eq(201)
      expect(result.body).to be_an_instance_of(Models::C)
      expect(result.body.http_code.to_i).to eq(201)
    end

    it 'should get 200->201->404->404 valid' do
      expect { @multiple_resp_client.get200model_a201model_c404model_ddefault_error404valid_async().value! }.to raise_exception_with_code(404)
    end

    it 'should get 200->201->404->400 valid' do
      expect { @multiple_resp_client.get200model_a201model_c404model_ddefault_error400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 202->204->202 none' do
      expect { @multiple_resp_client.get202none204none_default_error202none_async().value! }.to raise_exception_with_code(202)
    end

    it 'should get 202->204->204 none' do
      expect { @multiple_resp_client.get202none204none_default_error204none_async().value! }.to raise_exception_with_code(204)
    end

    it 'should get 202->204->400 valid' do
      expect { @multiple_resp_client.get202none204none_default_error400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 202->204->202 invalid' do
      expect { @multiple_resp_client.get202none204none_default_none202invalid_async().value! }.to raise_exception_with_code(202)
    end

    it 'should get 202->204->204 none' do
      expect { @multiple_resp_client.get202none204none_default_none204none_async().value! }.to raise_exception_with_code(204)
    end

    it 'should get 202->204->400 none' do
      expect { @multiple_resp_client.get202none204none_default_none400none_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 202->204->400 invalid' do
      expect { @multiple_resp_client.get202none204none_default_none400invalid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get default 200 valid' do
      result = @multiple_resp_client.get_default_model_a200valid_async().value!
      expect(result.response.status).to eq(200)
    end

    it 'should get default 200 none' do
      expect { @multiple_resp_client.get_default_model_a200none_async().value! }.to raise_exception_with_code(200)
    end

    it 'should get default 400 valid' do
      expect { @multiple_resp_client.get_default_model_a400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get default 400 none' do
      expect { @multiple_resp_client.get_default_model_a400none_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get default 200 invalid' do
      expect { @multiple_resp_client.get_default_none200invalid_async().value! }.to raise_exception_with_code(200)
    end

    it 'should get default none 200 none' do
      expect { @multiple_resp_client.get_default_none200none_async().value! }.to raise_exception_with_code(200)
    end

    it 'should get default none 400 invalid' do
      expect { @multiple_resp_client.get_default_none400invalid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get default none 400 none' do
      expect { @multiple_resp_client.get_default_none400none_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200 model_a 200 none' do
      result = @multiple_resp_client.get200model_a200none_async().value!
      expect(result.response.status).to eq(200)
      expect(result.body).to be_nil
    end

    it 'should get 200 model_a 200 valid' do
      result = @multiple_resp_client.get200model_a200valid_async().value!
      expect(result.response.status).to eq(200)
      expect(result.body.status_code.to_i).to eq(200)
    end

    it 'should get 200 model_a 200 invalid' do
      result = @multiple_resp_client.get200model_a200invalid_async().value!
      expect(result.response.status).to eq(200)
      expect(result.body).to be_an_instance_of(Models::A)
      expect(result.body.status_code).to be_nil
    end

    it 'should get 200 model_a 400 none' do
      expect { @multiple_resp_client.get200model_a400none_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200 model_a 400 valid' do
      expect { @multiple_resp_client.get200model_a400valid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200 model_a 400 invalid' do
      expect { @multiple_resp_client.get200model_a400invalid_async().value! }.to raise_exception_with_code(400)
    end

    it 'should get 200 model_a 202 valid' do
      expect { @multiple_resp_client.get200model_a202valid_async().value! }.to raise_exception_with_code(202)
    end
  end
end

end

redpajama_set_name: RedPajamaGithub


Learn the nature of thought to free yourself from your limited thinking. The mind is not a camera, it's a projector. Discover how to engage with your thoughts order to get your mind on the right track for success.


The purpose of this edit is to re-sequence and re-title the entire Daytona album to the way it was on Kanye's whiteboard when he first announced the project. I slightly edited every song to flow into each other smoothly.
7. How Do You Respond?


text:
package com.linkedin.pinot.routing;

import com.linkedin.pinot.common.config.AbstractTableConfig;
import com.linkedin.pinot.common.config.TableNameBuilder;
import com.linkedin.pinot.common.metadata.ZKMetadataProvider;
import com.linkedin.pinot.common.metadata.segment.OfflineSegmentZKMetadata;
import com.linkedin.pinot.common.utils.CommonConstants.Helix.TableType;
import com.linkedin.pinot.common.utils.time.TimeUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.apache.helix.ZNRecord;
import org.apache.helix.model.ExternalView;
import org.apache.helix.store.zk.ZkHelixPropertyStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelixExternalViewBasedTimeBoundaryService implements TimeBoundaryService {

  private static final Logger LOGGER = LoggerFactory.getLogger(HelixExternalViewBasedTimeBoundaryService.class);

  private static final String DAYS_SINCE_EPOCH = "daysSinceEpoch";
  private static final String HOURS_SINCE_EPOCH = "hoursSinceEpoch";
  private static final String MINUTES_SINCE_EPOCH = "minutesSinceEpoch";
  private static final String SECONDS_SINCE_EPOCH = "secondsSinceEpoch";

  private final ZkHelixPropertyStore<ZNRecord> _propertyStore;
  private final Map<String, TimeBoundaryInfo> _timeBoundaryInfoMap = new HashMap<String, TimeBoundaryInfo>();

  public HelixExternalViewBasedTimeBoundaryService(ZkHelixPropertyStore<ZNRecord> propertyStore) {
    _propertyStore = propertyStore;
  }

  public synchronized void updateTimeBoundaryService(ExternalView externalView) {
    if (_propertyStore == null) {
      return;
    }
    String tableName = externalView.getResourceName();
    // Do nothing for realtime table.
    if (TableNameBuilder.getTableTypeFromTableName(tableName) == TableType.REALTIME) {
      return;
    }

    Set<String> offlineSegmentsServing = externalView.getPartitionSet();
    if (offlineSegmentsServing.isEmpty()) {
      LOGGER.info("Skipping updating time boundary service for table '{}' with no offline segments.", tableName);
      return;
    }

    AbstractTableConfig offlineTableConfig = ZKMetadataProvider.getOfflineTableConfig(_propertyStore, tableName);
    String timeType = offlineTableConfig.getValidationConfig().getTimeType();
    TimeUnit tableTimeUnit = getTimeUnitFromString(timeType);
    if (tableTimeUnit == null) {
      LOGGER.info("Skipping updating time boundary service for table '{}' with null timeUnit, config time type: {}.",
          tableName, timeType);
      return;
    }

    // Bulk reading all segment zk-metadata at once is more efficient than reading one at a time.
    List<OfflineSegmentZKMetadata> segmentZKMetadataList =
        ZKMetadataProvider.getOfflineSegmentZKMetadataListForTable(_propertyStore, tableName);

    long maxTimeValue = computeMaxSegmentEndTimeForTable(segmentZKMetadataList, tableTimeUnit);
    TimeBoundaryInfo timeBoundaryInfo = new TimeBoundaryInfo();
    timeBoundaryInfo.setTimeColumn(offlineTableConfig.getValidationConfig().getTimeColumnName());

    timeBoundaryInfo.setTimeValue(Long.toString(maxTimeValue));
    _timeBoundaryInfoMap.put(tableName, timeBoundaryInfo);

    LOGGER.info("Updated time boundary service for table '{}', maxTime: {}", tableName, maxTimeValue);
  }

  /**
   * Compute maximum end time across a list of segment zk-metadata.
   *
   * @param segmentZKMetadataList List of Segment zk metadata for which to compute the max end time.
   * @param tableTimeUnit Time Unit for table
   * @return Max end time across all segments.
   */
  private long computeMaxSegmentEndTimeForTable(List<OfflineSegmentZKMetadata> segmentZKMetadataList,
      TimeUnit tableTimeUnit) {
    long maxTimeValue = -1;

    for (OfflineSegmentZKMetadata metadata : segmentZKMetadataList) {
      long endTime = metadata.getEndTime();
      if (endTime <= 0) {
        continue;
      }

      // Convert all segment times to table's time unit, before comparison.
      TimeUnit segmentTimeUnit = metadata.getTimeUnit();
      if (segmentTimeUnit != null) {
        endTime = tableTimeUnit.convert(endTime, segmentTimeUnit);
      }
      maxTimeValue = Math.max(maxTimeValue, endTime);
    }
    return maxTimeValue;
  }

  private TimeUnit getTimeUnitFromString(String timeTypeString) {
    // If input data does not have a time column, no need to fire an exception.
    if ((timeTypeString == null) || timeTypeString.isEmpty()) {
      return null;
    }

    TimeUnit timeUnit = TimeUtils.timeUnitFromString(timeTypeString);

    // Check legacy time formats
    if (timeUnit == null) {
      if (timeTypeString.equalsIgnoreCase(DAYS_SINCE_EPOCH)) {
        timeUnit = TimeUnit.DAYS;
      }
      if (timeTypeString.equalsIgnoreCase(HOURS_SINCE_EPOCH)) {
        timeUnit = TimeUnit.HOURS;
      }
      if (timeTypeString.equalsIgnoreCase(MINUTES_SINCE_EPOCH)) {
        timeUnit = TimeUnit.MINUTES;
      }
      if (timeTypeString.equalsIgnoreCase(SECONDS_SINCE_EPOCH)) {
        timeUnit = TimeUnit.SECONDS;
      }
    }

    if (timeUnit == null) {
      throw new RuntimeException("Not supported time type for: " + timeTypeString);
    }
    return timeUnit;
  }

  @Override
  public void remove(String tableName) {
    _timeBoundaryInfoMap.remove(tableName);
  }

  @Override
  public TimeBoundaryInfo getTimeBoundaryInfoFor(String table) {
    return _timeBoundaryInfoMap.get(table);
  }
}