text:
package io.shardingsphere.shardingjdbc.jdbc.unsupported;

import io.shardingsphere.shardingjdbc.common.base.AbstractShardingJDBCDatabaseAndTableTest;
import io.shardingsphere.shardingjdbc.jdbc.core.connection.ShardingConnection;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public final class UnsupportedOperationConnectionTest extends AbstractShardingJDBCDatabaseAndTableTest {

    private final List<ShardingConnection> shardingConnections = new ArrayList<>();

    @Before
    public void init() {
        shardingConnections.add(getShardingDataSource().getConnection());
    }

    @After
    public void close() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.close();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertPrepareCall() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.prepareCall("");
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertPrepareCallWithResultSetTypeAndResultSetConcurrency() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.prepareCall("", 0, 0);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertPrepareCallWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.prepareCall("", 0, 0, 0);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertNativeSQL() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.nativeSQL("");
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetSavepoint() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setSavepoint();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetSavepointWithName() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setSavepoint("");
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertReleaseSavepoint() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.releaseSavepoint(null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertRollback() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.rollback(null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertAbort() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.abort(null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetCatalog() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getCatalog();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetCatalog() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setCatalog("");
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetSchema() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getSchema();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetSchema() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setSchema("");
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetTypeMap() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getTypeMap();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetTypeMap() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setTypeMap(null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetNetworkTimeout() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getNetworkTimeout();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertSetNetworkTimeout() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.setNetworkTimeout(null, 0);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateClob() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createClob();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateBlob() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createBlob();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateNClob() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createNClob();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateSQLXML() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createSQLXML();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateArrayOf() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createArrayOf("", null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertCreateStruct() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.createStruct("", null);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertIsValid() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.isValid(0);
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetClientInfo() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getClientInfo();
        }
    }

    @Test(expected = SQLFeatureNotSupportedException.class)
    public void assertGetClientInfoWithName() throws SQLException {
        for (ShardingConnection each : shardingConnections) {
            each.getClientInfo("");
        }
    }

    @Test(expected = UnsupportedOperationException.class)
    public void assertSetClientInfo() {
        for (ShardingConnection each : shardingConnections) {
            each.setClientInfo("", "");
        }
    }

    @Test(expected = UnsupportedOperationException.class)
    public void assertSetClientInfoWithProperties() {
        for (ShardingConnection each : shardingConnections) {
            each.setClientInfo(new Properties());
        }
    }
}


text:
module.exports = function(config) {
  config.set({
    basePath: '..',
    frameworks: ['dart-unittest'],

    // list of files / patterns to load in the browser
    files: [
      'test/*_test.dart',
      {pattern: '**/*.dart', watched: false, included: false, served: true},
      {pattern: 'packages/browser/dart.js', watched: false, included: true, served: true},
    ],

    autoWatch: true,

    plugins: [
      'karma-dart',
      'karma-chrome-launcher'
    ]
  });
};

redpajama_set_name: RedPajamaGithub


text:
require 'ebay/types/feedback_period'
require 'ebay/types/average_rating_details'

module Ebay # :nodoc:
  module Types # :nodoc:
    # == Attributes
    #  array_node :bid_retraction_feedback_periods, 'BidRetractionFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
    #  array_node :negative_feedback_periods, 'NegativeFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
    #  array_node :neutral_feedback_periods, 'NeutralFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
    #  array_node :positive_feedback_periods, 'PositiveFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
    #  array_node :total_feedback_periods, 'TotalFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
    #  numeric_node :neutral_comment_count_from_suspended_users, 'NeutralCommentCountFromSuspendedUsers', :optional => true
    #  numeric_node :unique_negative_feedback_count, 'UniqueNegativeFeedbackCount', :optional => true
    #  numeric_node :unique_positive_feedback_count, 'UniquePositiveFeedbackCount', :optional => true
    #  array_node :seller_average_rating_details, 'SellerAverageRatingDetailArray', 'AverageRatingDetails', :class => AverageRatingDetails, :default_value => []
    class FeedbackSummary
      include XML::Mapping
      include Initializer
      root_element_name 'FeedbackSummary'
      array_node :bid_retraction_feedback_periods, 'BidRetractionFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
      array_node :negative_feedback_periods, 'NegativeFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
      array_node :neutral_feedback_periods, 'NeutralFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
      array_node :positive_feedback_periods, 'PositiveFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
      array_node :total_feedback_periods, 'TotalFeedbackPeriodArray', 'FeedbackPeriod', :class => FeedbackPeriod, :default_value => []
      numeric_node :neutral_comment_count_from_suspended_users, 'NeutralCommentCountFromSuspendedUsers', :optional => true
      numeric_node :unique_negative_feedback_count, 'UniqueNegativeFeedbackCount', :optional => true
      numeric_node :unique_positive_feedback_count, 'UniquePositiveFeedbackCount', :optional => true
      array_node :seller_average_rating_details, 'SellerAverageRatingDetailArray', 'AverageRatingDetails', :class => AverageRatingDetails, :default_value => []
    end
  end
end


text:
package messages

type Message struct {
	Text    string
	User    string
	Channel string
}

type Response struct {
	Text string
}


text:
{% extends "layout.html" %}

{% block title %}{{ _('Login') }}{% endblock %}

{% block header %}{% endblock %}

{% block main %}

            {{ _('Flask-Boot') }}

        <form class="form-horizontal m-t-20" action="/login" method="post">
            {{ form.csrf_token }}
            {{ form.next_url }}

                    {{ form.email(class='form-control', placeholder=_('Email')) }}
                    {% if form.email.errors %}

{{ form.email.errors[0] }}

                    {% endif %}

                    {{ form.password(class='form-control', placeholder=_('Password')) }}
                    {% if form.password.errors %}

{{ form.password.errors[0] }}

                    {% endif %}

                        {{ form.remember(checked='checked') }}

                            {{ _('Remember me') }}

                    <button class="btn btn-primary btn-custom w-md" type="submit">{{ _('Login') }}</button>

                         {{ _('Forgot your password?') }}

                    {{ _('Create an account') }}

        </form>

{% endblock %}

{% block footer %}{% endblock %}

{% block script %}

{% endblock %}


text:
(function(ko, $) {

  var PATHS = Object.freeze({
    COMPONENTS: "/app/components/"
  });

  var customComponentLoader = {
    getConfig: function(name, cb) {
      cb({
        template: { path: PATHS.COMPONENTS + name + ".tmpl.html" },
        viewModel: { path: PATHS.COMPONENTS + name + ".js" }
      });
    },
    loadTemplate: function(name, templateConfig, callback) {
      var path = templateConfig.path;
      if (path == null) {
        return;
      }

      $.get(path, function(markupString) {
        ko.components.defaultLoader.loadTemplate(name, markupString, callback);
      });
    },
    loadViewModel: function(name, viewModelConfig, callback) {
      var path = viewModelConfig.path;
      if (path == null) {
        return;
      }

      $.get(path, function(markupString) {
        var viewModel = eval(markupString);
        ko.components.defaultLoader.loadViewModel(name, viewModel, callback);
      });
    }
  };

  ko.components.loaders.unshift(customComponentLoader);

})(ko, jQuery);


text:
This is a starter kit with "batteries included" to get you up and running with
React and Flux more quickly.

## Usage

Branches:

* [`master`](https://github.com/SirCmpwn/react-starter-kit/tree/master) - empty starter kit
* [`todo`](https://github.com/SirCmpwn/react-starter-kit/tree/todo) - simple Todo list example (you are here)

To start your own React application based on this:

    git clone -b master https://github.com/SirCmpwn/react-starter-kit.git
    mv react-starter-kit my-awesome-app
    cd my-awesome-app
    ./bootstrap.sh

## What you get

* Some no-brainer dependencies:
    * React
    * Flux (dispatcher)
    * Babel (ES6/ES7/JSX transpiling)
    * Underscore
* A base Store class
* An entry point

## Todo Example

This isn't the usual TodoMVC style application. It's very very stripped down so
that there's the minimal amount of code to read to grok it. You can get it like so:

    git clone -b todo https://github.com/SirCmpwn/react-starter-kit.git
    cd react-starter-kit
    npm install
    npm start # run dev server


text:
/*
 * $Id: Qos_Helper.h 5871 2012-11-08 22:29:43Z mitza $
 *
 *
 * Distributed under the OpenDDS License.
 * See: http://www.opendds.org/license.html
 */

#ifndef OPENDDS_DCPS_QOS_HELPER_H
#define OPENDDS_DCPS_QOS_HELPER_H

#include "dds/DdsDcpsC.h"
#include "ace/OS_NS_sys_time.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
#pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

namespace OpenDDS {
namespace DCPS {

class Service_Participant;

ACE_INLINE OpenDDS_Dcps_Export
ACE_Time_Value time_to_time_value(const DDS::Time_t& t);

ACE_INLINE OpenDDS_Dcps_Export
DDS::Time_t time_value_to_time(const ACE_Time_Value& tv);

ACE_INLINE OpenDDS_Dcps_Export
ACE_Time_Value duration_to_time_value(const DDS::Duration_t& t);

ACE_INLINE OpenDDS_Dcps_Export
ACE_Time_Value duration_to_absolute_time_value(const DDS::Duration_t& t,
                                               const ACE_Time_Value now = ACE_OS::gettimeofday());

ACE_INLINE OpenDDS_Dcps_Export
DDS::Duration_t time_value_to_duration(const ACE_Time_Value& tv);

ACE_INLINE OpenDDS_Dcps_Export
DDS::Duration_t time_to_duration(const DDS::Time_t& t);

ACE_INLINE OpenDDS_Dcps_Export
CORBA::Long get_instance_sample_list_depth(
  DDS::HistoryQosPolicyKind history,
  long                        history_depth,
  long                        max_samples_per_instance);

/// Validate DDS::Duration_t value (infinite or positive and
/// non-zero).
ACE_INLINE OpenDDS_Dcps_Export
bool valid_duration(DDS::Duration_t const & t);

/// Check if given duration is either infinite or greater than or
/// equal to zero.
ACE_INLINE OpenDDS_Dcps_Export
bool non_negative_duration(DDS::Duration_t const & t);

/**
 * @class Qos_Helper
 *
 * @brief This class implements methods that verify whether a qos is
 *        valid, consistent and changeable.
 *
 * valid - the values are in acceptable ranges without respect
 *         to any other values.
 *
 * consistent - the values are consistent with each other.
 *         The spec sometimes calls this "compatible" but I
 *         this compatible should be reserved for matching
 *         QoS of subscriptions and publications.
 *         The spec is confusing in its inconsistency of the
 *         use of "compatible" and "consistent".
 *
 * The qos supported in current implementation:
 *         Liveliness  :   kind = AUTOMATIC
 *         Reliability :   kind = RELIABLE | BEST_EFFORT
 *                         max_blocking_time
 *         History     :   kind = KEEP_ALL | KEEP_LAST
 *                         depth > 1
 *         RESOURCE_LIMITS : max_samples_per_instance
 *
 * Other than these supported qos, any qos that is different from the
 * initial value is invalid.
 *
 * @note Since in the first implementation of DSS in TAO a limited
 *       number of QoS values are allowed to be modified, the
 *       consistency test on QoS settings have not been
 *       implemented to check future "valid" QoS values.
 *
 * @note None of the supported QoS in the first implementation are
 *       changeable. The changed value will be checked per the QoS
 *       table in the DDS specification.
 */
class OpenDDS_Dcps_Export Qos_Helper {
public:

  static bool consistent(
    DDS::ResourceLimitsQosPolicy const & resource_limits,
    DDS::HistoryQosPolicy const & history);

  static bool consistent(
    DDS::DeadlineQosPolicy const & deadline,
    DDS::TimeBasedFilterQosPolicy const & time_based_filter);

  static bool consistent(const DDS::DomainParticipantQos& qos);

  static bool consistent(const DDS::TopicQos& qos);

  static bool consistent(const DDS::DataWriterQos& qos);

  static bool consistent(const DDS::PublisherQos& qos);

  static bool consistent(const DDS::DataReaderQos& qos);

  static bool consistent(const DDS::SubscriberQos& qos);

  static bool consistent(const DDS::DomainParticipantFactoryQos & qos);

  static bool valid(const DDS::UserDataQosPolicy& qos);

  static bool valid(const DDS::TopicDataQosPolicy & qos);

  static bool valid(const DDS::GroupDataQosPolicy& qos);

  static bool valid(const DDS::TransportPriorityQosPolicy& qos);

  static bool valid(const DDS::LifespanQosPolicy& qos);

  static bool valid(const DDS::DurabilityQosPolicy& qos);

#ifndef OPENDDS_NO_PERSISTENCE_PROFILE
  static bool valid(const DDS::DurabilityServiceQosPolicy& qos);
#endif

  static bool valid(const DDS::PresentationQosPolicy& qos);

  static bool valid(const DDS::DeadlineQosPolicy& qos);

  static bool valid(const DDS::LatencyBudgetQosPolicy& qos);

  static bool valid(const DDS::OwnershipQosPolicy& qos);

#ifndef OPENDDS_NO_OWNERSHIP_KIND_EXCLUSIVE
  static bool valid(const DDS::OwnershipStrengthQosPolicy& qos);
#endif

  static bool valid(const DDS::LivelinessQosPolicy& qos);

  static bool valid(const DDS::TimeBasedFilterQosPolicy& qos);

  static bool valid(const DDS::PartitionQosPolicy& qos);

  static bool valid(const DDS::ReliabilityQosPolicy& qos);

  static bool valid(const DDS::DestinationOrderQosPolicy& qos);

  static bool valid(const DDS::HistoryQosPolicy& qos);

  static bool valid(const DDS::ResourceLimitsQosPolicy& qos);

  static bool valid(const DDS::EntityFactoryQosPolicy& qos);

  static bool valid(const DDS::WriterDataLifecycleQosPolicy& qos);

  static bool valid(const DDS::ReaderDataLifecycleQosPolicy& qos);

  static bool valid(const DDS::DomainParticipantQos& qos);

  static bool valid(const DDS::TopicQos& qos);

  static bool valid(const DDS::DataWriterQos& qos);

  static bool valid(const DDS::PublisherQos& qos);

  static bool valid(const DDS::DataReaderQos& qos);

  static bool valid(const DDS::SubscriberQos& qos);

  static bool valid(const DDS::DomainParticipantFactoryQos& qos);

  static bool changeable(const DDS::UserDataQosPolicy& qos1,
                         const DDS::UserDataQosPolicy& qos2);

  static bool changeable(const DDS::TopicDataQosPolicy & qos1,
                         const DDS::TopicDataQosPolicy & qos2);

  static bool changeable(const DDS::GroupDataQosPolicy& qos1,
                         const DDS::GroupDataQosPolicy& qos2);

  static bool changeable(const DDS::TransportPriorityQosPolicy& qos1,
                         const DDS::TransportPriorityQosPolicy& qos2);

  static bool changeable(const DDS::LifespanQosPolicy& qos1,
                         const DDS::LifespanQosPolicy& qos2);

  static bool changeable(const DDS::DurabilityQosPolicy& qos1,
                         const DDS::DurabilityQosPolicy& qos2);

#ifndef OPENDDS_NO_PERSISTENCE_PROFILE
  static bool changeable(const DDS::DurabilityServiceQosPolicy& qos1,
                         const DDS::DurabilityServiceQosPolicy& qos2);
#endif

  static bool changeable(const DDS::PresentationQosPolicy& qos1,
                         const DDS::PresentationQosPolicy& qos2);

  static bool changeable(const DDS::DeadlineQosPolicy& qos1,
                         const DDS::DeadlineQosPolicy& qos2);

  static bool changeable(const DDS::LatencyBudgetQosPolicy& qos1,
                         const DDS::LatencyBudgetQosPolicy& qos2);

  static bool changeable(const DDS::OwnershipQosPolicy& qos1,
                         const DDS::OwnershipQosPolicy& qos2);

#ifndef OPENDDS_NO_OWNERSHIP_KIND_EXCLUSIVE
  static bool changeable(const DDS::OwnershipStrengthQosPolicy& qos1,
                         const DDS::OwnershipStrengthQosPolicy& qos2);
#endif

  static bool changeable(const DDS::LivelinessQosPolicy& qos1,
                         const DDS::LivelinessQosPolicy& qos2);

  static bool changeable(const DDS::TimeBasedFilterQosPolicy& qos1,
                         const DDS::TimeBasedFilterQosPolicy& qos2);

  static bool changeable(const DDS::PartitionQosPolicy& qos1,
                         const DDS::PartitionQosPolicy& qos2);

  static bool changeable(const DDS::ReliabilityQosPolicy& qos1,
                         const DDS::ReliabilityQosPolicy& qos2);

  static bool changeable(const DDS::DestinationOrderQosPolicy& qos1,
                         const DDS::DestinationOrderQosPolicy& qos2);

  static bool changeable(const DDS::HistoryQosPolicy& qos1,
                         const DDS::HistoryQosPolicy& qos2);

  static bool changeable(const DDS::ResourceLimitsQosPolicy& qos1,
                         const DDS::ResourceLimitsQosPolicy& qos2);

  static bool changeable(const DDS::EntityFactoryQosPolicy& qos1,
                         const DDS::EntityFactoryQosPolicy& qos2) ;

  static bool changeable(const DDS::WriterDataLifecycleQosPolicy& qos1,
                         const DDS::WriterDataLifecycleQosPolicy& qos2);

  static bool changeable(const DDS::ReaderDataLifecycleQosPolicy& qos1,
                         const DDS::ReaderDataLifecycleQosPolicy& qos2);

  static bool changeable(const DDS::DomainParticipantQos& qos1,
                         const DDS::DomainParticipantQos& qos2);

  static bool changeable(const DDS::TopicQos& qos1,
                         const DDS::TopicQos& qos2);

  static bool changeable(const DDS::DataWriterQos& qos1,
                         const DDS::DataWriterQos& qos2);

  static bool changeable(const DDS::PublisherQos& qos1,
                         const DDS::PublisherQos& qos2);

  static bool changeable(const DDS::DataReaderQos& qos1,
                         const DDS::DataReaderQos& qos2);

  static bool changeable(const DDS::SubscriberQos& qos1,
                         const DDS::SubscriberQos& qos2);

  static bool changeable(const DDS::DomainParticipantFactoryQos& qos1,
                         const DDS::DomainParticipantFactoryQos& qos2);

  static bool copy_from_topic_qos(DDS::DataReaderQos& a_datareader_qos,
                                  const DDS::TopicQos& a_topic_qos);

  static bool copy_from_topic_qos(DDS::DataWriterQos& a_datareader_qos,
                                  const DDS::TopicQos& a_topic_qos);
};

ACE_INLINE OpenDDS_Dcps_Export
bool operator== (const DDS::Duration_t& t1,
                 const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator!= (const DDS::Duration_t& t1,
                 const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator<(const DDS::Duration_t& t1,
                const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator<= (const DDS::Duration_t& t1,
                 const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator> (const DDS::Duration_t& t1,
                const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator>= (const DDS::Duration_t& t1,
                 const DDS::Duration_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator!(const DDS::Time_t& t);

ACE_INLINE OpenDDS_Dcps_Export
bool operator==(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator!=(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator<(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator<=(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator>(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator>=(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
DDS::Time_t operator-(const DDS::Time_t& t1, const DDS::Time_t& t2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::UserDataQosPolicy& qos1,
                  const DDS::UserDataQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::TopicDataQosPolicy & qos1,
                  const DDS::TopicDataQosPolicy & qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::GroupDataQosPolicy& qos1,
                  const DDS::GroupDataQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::TransportPriorityQosPolicy& qos1,
                  const DDS::TransportPriorityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::LifespanQosPolicy& qos1,
                  const DDS::LifespanQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DurabilityQosPolicy& qos1,
                  const DDS::DurabilityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DurabilityServiceQosPolicy& qos1,
                  const DDS::DurabilityServiceQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::PresentationQosPolicy& qos1,
                  const DDS::PresentationQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DeadlineQosPolicy& qos1,
                  const DDS::DeadlineQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::LatencyBudgetQosPolicy& qos1,
                  const DDS::LatencyBudgetQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::OwnershipQosPolicy& qos1,
                  const DDS::OwnershipQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::OwnershipStrengthQosPolicy& qos1,
                  const DDS::OwnershipStrengthQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::LivelinessQosPolicy& qos1,
                  const DDS::LivelinessQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::TimeBasedFilterQosPolicy& qos1,
                  const DDS::TimeBasedFilterQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::PartitionQosPolicy& qos1,
                  const DDS::PartitionQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::ReliabilityQosPolicy& qos1,
                  const DDS::ReliabilityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DestinationOrderQosPolicy& qos1,
                  const DDS::DestinationOrderQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::HistoryQosPolicy& qos1,
                  const DDS::HistoryQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::ResourceLimitsQosPolicy& qos1,
                  const DDS::ResourceLimitsQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::EntityFactoryQosPolicy& qos1,
                  const DDS::EntityFactoryQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::WriterDataLifecycleQosPolicy& qos1,
                  const DDS::WriterDataLifecycleQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::ReaderDataLifecycleQosPolicy& qos1,
                  const DDS::ReaderDataLifecycleQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DomainParticipantQos& qos1,
                  const DDS::DomainParticipantQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::TopicQos& qos1,
                  const DDS::TopicQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DataWriterQos& qos1,
                  const DDS::DataWriterQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::PublisherQos& qos1,
                  const DDS::PublisherQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DataReaderQos& qos1,
                  const DDS::DataReaderQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::SubscriberQos& qos1,
                  const DDS::SubscriberQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator == (const DDS::DomainParticipantFactoryQos& qos1,
                  const DDS::DomainParticipantFactoryQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::UserDataQosPolicy& qos1,
                  const DDS::UserDataQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::TopicDataQosPolicy & qos1,
                  const DDS::TopicDataQosPolicy & qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::GroupDataQosPolicy& qos1,
                  const DDS::GroupDataQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::TransportPriorityQosPolicy& qos1,
                  const DDS::TransportPriorityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::LifespanQosPolicy& qos1,
                  const DDS::LifespanQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DurabilityQosPolicy& qos1,
                  const DDS::DurabilityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DurabilityServiceQosPolicy& qos1,
                  const DDS::DurabilityServiceQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::PresentationQosPolicy& qos1,
                  const DDS::PresentationQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DeadlineQosPolicy& qos1,
                  const DDS::DeadlineQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::LatencyBudgetQosPolicy& qos1,
                  const DDS::LatencyBudgetQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::OwnershipQosPolicy& qos1,
                  const DDS::OwnershipQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::OwnershipStrengthQosPolicy& qos1,
                  const DDS::OwnershipStrengthQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::LivelinessQosPolicy& qos1,
                  const DDS::LivelinessQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::TimeBasedFilterQosPolicy& qos1,
                  const DDS::TimeBasedFilterQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::PartitionQosPolicy& qos1,
                  const DDS::PartitionQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::ReliabilityQosPolicy& qos1,
                  const DDS::ReliabilityQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DestinationOrderQosPolicy& qos1,
                  const DDS::DestinationOrderQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::HistoryQosPolicy& qos1,
                  const DDS::HistoryQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::ResourceLimitsQosPolicy& qos1,
                  const DDS::ResourceLimitsQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::EntityFactoryQosPolicy& qos1,
                  const DDS::EntityFactoryQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::WriterDataLifecycleQosPolicy& qos1,
                  const DDS::WriterDataLifecycleQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::ReaderDataLifecycleQosPolicy& qos1,
                  const DDS::ReaderDataLifecycleQosPolicy& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DomainParticipantQos& qos1,
                  const DDS::DomainParticipantQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::TopicQos& qos1,
                  const DDS::TopicQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DataWriterQos& qos1,
                  const DDS::DataWriterQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::PublisherQos& qos1,
                  const DDS::PublisherQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DataReaderQos& qos1,
                  const DDS::DataReaderQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::SubscriberQos& qos1,
                  const DDS::SubscriberQos& qos2);

ACE_INLINE OpenDDS_Dcps_Export
bool operator != (const DDS::DomainParticipantFactoryQos& qos1,
                  const DDS::DomainParticipantFactoryQos& qos2);

} // namespace DCPS
} // namespace OpenDDS

#if defined(__ACE_INLINE__)
#include "Qos_Helper.inl"
#endif /* __ACE_INLINE__ */

#endif /* OPENDDS_DCPS_QOS_HELPER_H */


text:
webpackJsonp([2],{

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(module) {/* global window */
	'use strict';

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	var Form = __webpack_require__(517);
	var React = __webpack_require__(181);
	var ReactDOM = __webpack_require__(2);

	var Page = function () {
	    function Page() {
	        _classCallCheck(this, Page);
	    }

	    _createClass(Page, null, [{
	        key: 'blastoff',
	        value: function blastoff() {

	            this.mainElement = ReactDOM.render(React.createElement(Form, null), window.document.getElementById('app-mount'));
	        }
	    }]);

	    return Page;
	}();

	module.exports = Page;

	/* $lab:coverage:off$ */
	if (!module.parent) {
	    window.page = Page;
	    Page.blastoff();
	}
	/* $lab:coverage:on$ */
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)(module)))

/***/ },

/***/ 401:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

	var React = __webpack_require__(181);

	var propTypes = {
	    type: React.PropTypes.oneOf(['success', 'info', 'warning', 'danger']),
	    onClose: React.PropTypes.func,
	    message: React.PropTypes.string
	};

	var Alert = function (_React$Component) {
	    _inherits(Alert, _React$Component);

	    function Alert() {
	        _classCallCheck(this, Alert);

	        return _possibleConstructorReturn(this, (Alert.__proto__ || Object.getPrototypeOf(Alert)).apply(this, arguments));
	    }

	    _createClass(Alert, [{
	        key: 'render',
	        value: function render() {

	            var close = void 0;

	            if (this.props.onClose) {
	                close = React.createElement(
	                    'button',
	                    {
	                        type: 'button',
	                        className: 'close',
	                        onClick: this.props.onClose },
	                    '\xD7'
	                );
	            }

	            return React.createElement(
	                'div',
	                { className: 'alert alert-' + this.props.type },
	                close,
	                this.props.message
	            );
	        }
	    }]);

	    return Alert;
	}(React.Component);

	Alert.propTypes = propTypes;

	module.exports = Alert;

/***/ },

/***/ 517:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

	var Actions = __webpack_require__(518);
	var Alert = __webpack_require__(401);
	var Button = __webpack_require__(402);
	var ControlGroup = __webpack_require__(403);
	var React = __webpack_require__(181);
	var Spinner = __webpack_require__(405);
	var Store = __webpack_require__(520);
	var TextControl = __webpack_require__(406);
	var TextareaControl = __webpack_require__(521);

	var Form = function (_React$Component) {
	    _inherits(Form, _React$Component);

	    function Form(props) {
	        _classCallCheck(this, Form);

	        var _this = _possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props));

	        _this.input = {};
	        _this.state = Store.getState();
	        return _this;
	    }

	    _createClass(Form, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {

	            this.unsubscribeStore = Store.subscribe(this.onStoreChange.bind(this));

	            if (this.input.name) {
	                this.input.name.focus();
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {

	            this.unsubscribeStore();
	        }
	    }, {
	        key: 'onStoreChange',
	        value: function onStoreChange() {

	            this.setState(Store.getState());
	        }
	    }, {
	        key: 'handleSubmit',
	        value: function handleSubmit(event) {

	            event.preventDefault();
	            event.stopPropagation();

	            Actions.sendMessage({
	                name: this.input.name.value(),
	                email: this.input.email.value(),
	                message: this.input.message.value()
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this2 = this;

	            var alert = [];

	            if (this.state.success) {
	                alert = React.createElement(Alert, {
	                    type: 'success',
	                    message: 'Success. We have received your message.'
	                });
	            } else if (this.state.error) {
	                alert = React.createElement(Alert, {
	                    type: 'danger',
	                    message: this.state.error
	                });
	            }

	            var formElements = void 0;

	            if (!this.state.success) {
	                formElements = React.createElement(
	                    'fieldset',
	                    null,
	                    React.createElement(TextControl, {
	                        ref: function ref(c) {
	                            return _this2.input.name = c;
	                        },
	                        name: 'name',
	                        label: 'Your name',
	                        hasError: this.state.hasError.name,
	                        help: this.state.help.name,
	                        disabled: this.state.loading
	                    }),
	                    React.createElement(TextControl, {
	                        ref: function ref(c) {
	                            return _this2.input.email = c;
	                        },
	                        name: 'email',
	                        label: 'Your email',
	                        hasError: this.state.hasError.email,
	                        help: this.state.help.email,
	                        disabled: this.state.loading
	                    }),
	                    React.createElement(TextareaControl, {
	                        ref: function ref(c) {
	                            return _this2.input.message = c;
	                        },
	                        name: 'message',
	                        label: 'Message',
	                        rows: '5',
	                        hasError: this.state.hasError.message,
	                        help: this.state.help.message,
	                        disabled: this.state.loading
	                    }),
	                    React.createElement(
	                        ControlGroup,
	                        { hideLabel: true, hideHelp: true },
	                        React.createElement(
	                            Button,
	                            {
	                                type: 'submit',
	                                inputClasses: { 'btn-primary': true },
	                                disabled: this.state.loading },
	                            'Send message',
	                            React.createElement(Spinner, { space: 'left', show: this.state.loading })
	                        )
	                    )
	                );
	            }

	            return React.createElement(
	                'section',
	                null,
	                React.createElement(
	                    'h1',
	                    { className: 'page-header' },
	                    'Send a message'
	                ),
	                React.createElement(
	                    'form',
	                    { onSubmit: this.handleSubmit.bind(this) },
	                    alert,
	                    formElements
	                )
	            );
	        }
	    }]);

	    return Form;
	}(React.Component);

	module.exports = Form;

/***/ },

/***/ 518:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	var ApiActions = __webpack_require__(358);
	var Constants = __webpack_require__(519);
	var Store = __webpack_require__(520);

	var Actions = function () {
	    function Actions() {
	        _classCallCheck(this, Actions);
	    }

	    _createClass(Actions, null, [{
	        key: 'sendMessage',
	        value: function sendMessage(data) {

	            ApiActions.post('/api/contact', data, Store, Constants.SEND_MESSAGE, Constants.SEND_MESSAGE_RESPONSE);
	        }
	    }]);

	    return Actions;
	}();

	module.exports = Actions;

/***/ },

/***/ 519:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var FluxConstant = __webpack_require__(375);

	module.exports = FluxConstant.set(['SEND_MESSAGE', 'SEND_MESSAGE_RESPONSE']);

/***/ },

/***/ 520:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var Constants = __webpack_require__(519);
	var ObjectAssign = __webpack_require__(23);
	var ParseValidation = __webpack_require__(378);
	var Redux = __webpack_require__(380);

	var initialState = {
	    loading: false,
	    success: false,
	    error: undefined,
	    hasError: {},
	    help: {}
	};
	var reducer = function reducer(state, action) {

	    if (action.type === Constants.SEND_MESSAGE) {
	        return ObjectAssign({}, state, {
	            loading: true
	        });
	    }

	    if (action.type === Constants.SEND_MESSAGE_RESPONSE) {
	        var validation = ParseValidation(action.response);

	        return ObjectAssign({}, state, {
	            loading: false,
	            success: !action.err,
	            error: validation.error,
	            hasError: validation.hasError,
	            help: validation.help
	        });
	    }

	    return state;
	};

	module.exports = Redux.createStore(reducer, initialState);

/***/ },

/***/ 521:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

	var ClassNames = __webpack_require__(246);
	var ControlGroup = __webpack_require__(403);
	var ObjectAssign = __webpack_require__(23);
	var React = __webpack_require__(181);

	var propTypes = {
	    disabled: React.PropTypes.bool,
	    hasError: React.PropTypes.bool,
	    help: React.PropTypes.string,
	    inputClasses: React.PropTypes.object,
	    label: React.PropTypes.string,
	    name: React.PropTypes.string,
	    onChange: React.PropTypes.func,
	    placeholder: React.PropTypes.string,
	    rows: React.PropTypes.string,
	    value: React.PropTypes.string
	};

	var TextareaControl = function (_React$Component) {
	    _inherits(TextareaControl, _React$Component);

	    function TextareaControl() {
	        _classCallCheck(this, TextareaControl);

	        return _possibleConstructorReturn(this, (TextareaControl.__proto__ || Object.getPrototypeOf(TextareaControl)).apply(this, arguments));
	    }

	    _createClass(TextareaControl, [{
	        key: 'focus',
	        value: function focus() {

	            return this.input.focus();
	        }
	    }, {
	        key: 'value',
	        value: function value() {

	            return this.input.value;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this2 = this;

	            var inputClasses = ClassNames(ObjectAssign({
	                'form-control': true
	            }, this.props.inputClasses));

	            return React.createElement(
	                ControlGroup,
	                {
	                    hasError: this.props.hasError,
	                    label: this.props.label,
	                    help: this.props.help },
	                React.createElement('textarea', {
	                    ref: function ref(c) {
	                        return _this2.input = c;
	                    },
	                    className: inputClasses,
	                    name: this.props.name,
	                    rows: this.props.rows,
	                    placeholder: this.props.placeholder,
	                    value: this.props.value,
	                    disabled: this.props.disabled ? 'disabled' : undefined,
	                    onChange: this.props.onChange
	                })
	            );
	        }
	    }]);

	    return TextareaControl;
	}(React.Component);

	TextareaControl.propTypes = propTypes;

	module.exports = TextareaControl;

/***/ }

});
//# sourceMappingURL=contact.map.js


text:
import scala.math._
import scala.collection.mutable.ArrayBuffer
import java.io.PrintWriter
import scala.io.Source

/**
  * Created by akorovin on 21.12.2016.
  */
object TestOut {
  def main(args: Array[String]): Unit = {
    val name = "Alex"
    val age = 23
    val weight = 65.5

    // printing out variables. need "s" in front of string
    println(s"Hello $name")

    // print out formatted. $age+1 - to calculate + 1 age, weight.2 for double decimal
    //                                          %c for characters
    //                                          %d for integers
    //                                          %f for floating point numbers
    //                                          %f for strings
    println(f"I am ${age + 1} and weight $weight%.2f")

    // justification example (5 spaces left or right)
    printf("'%5d'\n", 5) //justification right
    printf("'%-5d'\n", 5) //justification left
    printf("'%05d'\n", 5) //zero fill
    printf("'%.5f'\n", 3.14) //zero fill right after decimal number. 5 numbers after comma
    printf("'%-5s'", "hi")
  }
}


text:
RecyclerViewDemo
================

Demo application for the recycler view added to v20 of the support library

So far this does nothing except create a few itmes and populate a list with them.
Ideally will hope to expand the demo to include a custom layout manager and maybe some animations.


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FluentHub.Hub.ModelValidator
{
    public interface IModelValidator
    {
        bool CanValidate(object model);
        bool Validate(object model);
    }

    public interface IModelValidator<in TModel> : IModelValidator
    {
        bool Validate(TModel model);
    }
}


text:
package com.iluwatar;

public class Rogue extends PartyMemberBase {

	@Override
	public String toString() {
		return "Rogue";
	}

}


text:
from ._models_py3 import CheckNameRequest
from ._models_py3 import CheckNameResult
from ._models_py3 import DigitalTwinsDescription
from ._models_py3 import DigitalTwinsDescriptionListResult
from ._models_py3 import DigitalTwinsEndpointResource
from ._models_py3 import DigitalTwinsEndpointResourceListResult
from ._models_py3 import DigitalTwinsEndpointResourceProperties
from ._models_py3 import DigitalTwinsPatchDescription
from ._models_py3 import DigitalTwinsResource
from ._models_py3 import ErrorDefinition
from ._models_py3 import ErrorResponse
from ._models_py3 import EventGrid
from ._models_py3 import EventHub
from ._models_py3 import ExternalResource
from ._models_py3 import Operation
from ._models_py3 import OperationDisplay
from ._models_py3 import OperationListResult
from ._models_py3 import ServiceBus

from ._azure_digital_twins_management_client_enums import (
    EndpointProvisioningState,
    EndpointType,
    ProvisioningState,
    Reason,
)

__all__ = [
    'CheckNameRequest',
    'CheckNameResult',
    'DigitalTwinsDescription',
    'DigitalTwinsDescriptionListResult',
    'DigitalTwinsEndpointResource',
    'DigitalTwinsEndpointResourceListResult',
    'DigitalTwinsEndpointResourceProperties',
    'DigitalTwinsPatchDescription',
    'DigitalTwinsResource',
    'ErrorDefinition',
    'ErrorResponse',
    'EventGrid',
    'EventHub',
    'ExternalResource',
    'Operation',
    'OperationDisplay',
    'OperationListResult',
    'ServiceBus',
    'EndpointProvisioningState',
    'EndpointType',
    'ProvisioningState',
    'Reason',
]


text:
//
// Copyright (C) 1999-2005 Google, Inc.
//

// TODO(user): visit each const_cast.  Some of them are no longer necessary
// because last Single Unix Spec and grte v2 are more const-y.

#include "kudu/gutil/strings/util.h"

#include <algorithm>
#include <cassert>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <ostream>
#include <string>
#include <utility>
#include <vector>

#include <glog/logging.h>

#include "kudu/gutil/strings/ascii_ctype.h"
#include "kudu/gutil/strings/numbers.h"
#include "kudu/gutil/strings/stringpiece.h"
#include "kudu/gutil/stl_util.h"  // for string_as_array, STLAppendToString
#include "kudu/gutil/utf/utf.h"

using std::min;
using std::string;
using std::swap;
using std::vector;

#ifdef OS_WINDOWS
#ifdef min  // windows.h defines this to something silly
#undef min
#endif
#endif

// Use this instead of gmtime_r if you want to build for Windows.
// Windows doesn't have a 'gmtime_r', but it has the similar 'gmtime_s'.
// TODO(user): Probably belongs in //base:time_support.{cc|h}.
static struct tm* PortableSafeGmtime(const time_t* timep, struct tm* result) {
#ifdef OS_WINDOWS
  return gmtime_s(result, timep) == 0 ? result : NULL;
#else
  return gmtime_r(timep, result);
#endif  // OS_WINDOWS
}

char* strnstr(const char* haystack, const char* needle,
                     size_t haystack_len) {
  if (*needle == '\0') {
    return const_cast<char*>(haystack);
  }
  size_t needle_len = strlen(needle);
  char* where;
  while ((where = strnchr(haystack, *needle, haystack_len)) != nullptr) {
    if (where - haystack + needle_len > haystack_len) {
      return nullptr;
    }
    if (strncmp(where, needle, needle_len) == 0) {
      return where;
    }
    haystack_len -= where + 1 - haystack;
    haystack = where + 1;
  }
  return nullptr;
}

const char* strnprefix(const char* haystack, int haystack_size,
                              const char* needle, int needle_size) {
  if (needle_size > haystack_size) {
    return nullptr;
  } else {
    if (strncmp(haystack, needle, needle_size) == 0) {
      return haystack + needle_size;
    } else {
      return nullptr;
    }
  }
}

const char* strncaseprefix(const char* haystack, int haystack_size,
                                  const char* needle, int needle_size) {
  if (needle_size > haystack_size) {
    return nullptr;
  } else {
    if (strncasecmp(haystack, needle, needle_size) == 0) {
      return haystack + needle_size;
    } else {
      return nullptr;
    }
  }
}

char* strcasesuffix(char* str, const char* suffix) {
  const int lenstr = strlen(str);
  const int lensuffix = strlen(suffix);
  char* strbeginningoftheend = str + lenstr - lensuffix;

  if (lenstr >= lensuffix && 0 == strcasecmp(strbeginningoftheend, suffix)) {
    return (strbeginningoftheend);
  } else {
    return (nullptr);
  }
}

const char* strnsuffix(const char* haystack, int haystack_size,
                              const char* needle, int needle_size) {
  if (needle_size > haystack_size) {
    return nullptr;
  } else {
    const char* start = haystack + haystack_size - needle_size;
    if (strncmp(start, needle, needle_size) == 0) {
      return start;
    } else {
      return nullptr;
    }
  }
}

const char* strncasesuffix(const char* haystack, int haystack_size,
                           const char* needle, int needle_size) {
  if (needle_size > haystack_size) {
    return nullptr;
  } else {
    const char* start = haystack + haystack_size - needle_size;
    if (strncasecmp(start, needle, needle_size) == 0) {
      return start;
    } else {
      return nullptr;
    }
  }
}

char* strchrnth(const char* str, const char& c, int n) {
  if (str == nullptr)
    return nullptr;
  if (n <= 0)
    return const_cast<char*>(str);
  const char* sp;
  int k = 0;
  for (sp = str; *sp != '\0'; sp ++) {
    if (*sp == c) {
      ++k;
      if (k >= n)
        break;
    }
  }
  return (k < n) ? nullptr : const_cast<char*>(sp);
}

char* AdjustedLastPos(const char* str, char separator, int n) {
  if ( str == nullptr )
    return nullptr;
  const char* pos = nullptr;
  if ( n > 0 )
    pos = strchrnth(str, separator, n);

  // if n <= 0 or separator appears fewer than n times, get the last occurrence
  if ( pos == nullptr)
    pos = strrchr(str, separator);
  return const_cast<char*>(pos);
}

// ----------------------------------------------------------------------
// Misc. routines
// ----------------------------------------------------------------------

bool IsAscii(const char* str, int len) {
  const char* end = str + len;
  while (str < end) {
    if (!ascii_isascii(*str++)) {
      return false;
    }
  }
  return true;
}

// ----------------------------------------------------------------------
// StringReplace()
//    Give me a string and two patterns "old" and "new", and I replace
//    the first instance of "old" in the string with "new", if it
//    exists.  If "replace_all" is true then call this repeatedly until it
//    fails.  RETURN a new string, regardless of whether the replacement
//    happened or not.
// ----------------------------------------------------------------------

string StringReplace(const StringPiece& s, const StringPiece& oldsub,
                     const StringPiece& newsub, bool replace_all) {
  string ret;
  StringReplace(s, oldsub, newsub, replace_all, &ret);
  return ret;
}

// ----------------------------------------------------------------------
// StringReplace()
//    Replace the "old" pattern with the "new" pattern in a string,
//    and append the result to "res".  If replace_all is false,
//    it only replaces the first instance of "old."
// ----------------------------------------------------------------------

void StringReplace(const StringPiece& s, const StringPiece& oldsub,
                   const StringPiece& newsub, bool replace_all,
                   string* res) {
  if (oldsub.empty()) {
    res->append(s.data(), s.length());  // If empty, append the given string.
    return;
  }

  StringPiece::size_type start_pos = 0;
  StringPiece::size_type pos;
  do {
    pos = s.find(oldsub, start_pos);
    if (pos == StringPiece::npos) {
      break;
    }
    res->append(s.data() + start_pos, pos - start_pos);
    res->append(newsub.data(), newsub.length());
    // Start searching again after the "old".
    start_pos = pos + oldsub.length();
  } while (replace_all);
  res->append(s.data() + start_pos, s.length() - start_pos);
}

// ----------------------------------------------------------------------
// GlobalReplaceSubstring()
//    Replaces all instances of a substring in a string.  Does nothing
//    if 'substring' is empty.  Returns the number of replacements.
//
//    NOTE: The string pieces must not overlap s.
// ----------------------------------------------------------------------

int GlobalReplaceSubstring(const StringPiece& substring,
                           const StringPiece& replacement,
                           string* s) {
  CHECK(s != nullptr);
  if (s->empty() || substring.empty())
    return 0;
  string tmp;
  int num_replacements = 0;
  size_t pos = 0;
  for (size_t match_pos = s->find(substring.data(), pos, substring.length());
       match_pos != string::npos;
       pos = match_pos + substring.length(),
           match_pos = s->find(substring.data(), pos, substring.length())) {
    ++num_replacements;
    // Append the original content before the match.
    tmp.append(*s, pos, match_pos - pos);
    // Append the replacement for the match.
    tmp.append(replacement.begin(), replacement.end());
  }
  // Append the content after the last match. If no replacements were made, the
  // original string is left untouched.
  if (num_replacements > 0) {
    tmp.append(*s, pos, s->length() - pos);
    s->swap(tmp);
  }
  return num_replacements;
}

//---------------------------------------------------------------------------
// RemoveStrings()
//   Remove the strings from v given by the (sorted least -> greatest)
//   numbers in indices.
//   Order of v is *not* preserved.
//---------------------------------------------------------------------------
void RemoveStrings(vector<string>* v, const vector<int>& indices) {
  assert(v);
  assert(indices.size() <= v->size());
  // go from largest index to smallest so that smaller indices aren't
  // invalidated
  for (int lcv = indices.size() - 1; lcv >= 0; --lcv) {
#ifndef NDEBUG
    // verify that indices is sorted least->greatest
    if (indices.size() >= 2 && lcv > 0)
      // use LT and not LE because we should never see repeat indices
      CHECK_LT(indices[lcv-1], indices[lcv]);
#endif
    assert(indices[lcv] >= 0);
    assert(indices[lcv] < v->size());
    swap((*v)[indices[lcv]], v->back());
    v->pop_back();
  }
}

// ----------------------------------------------------------------------
// gstrcasestr is a case-insensitive strstr. Eventually we should just
// use the GNU libc version of strcasestr, but it isn't compiled into
// RedHat Linux by default in version 6.1.
//
// This function uses ascii_tolower() instead of tolower(), for speed.
// ----------------------------------------------------------------------

char *gstrcasestr(const char* haystack, const char* needle) {
  char c, sc;
  size_t len;

  if ((c = *needle++) != 0) {
    c = ascii_tolower(c);
    len = strlen(needle);
    do {
      do {
        if ((sc = *haystack++) == 0)
          return nullptr;
      } while (ascii_tolower(sc) != c);
    } while (strncasecmp(haystack, needle, len) != 0);
    haystack--;
  }
  // This is a const violation but strstr() also returns a char*.
  return const_cast<char*>(haystack);
}

// ----------------------------------------------------------------------
// gstrncasestr is a case-insensitive strnstr.
//    Finds the occurence of the (null-terminated) needle in the
//    haystack, where no more than len bytes of haystack is searched.
//    Characters that appear after a '\0' in the haystack are not searched.
//
// This function uses ascii_tolower() instead of tolower(), for speed.
// ----------------------------------------------------------------------
const char *gstrncasestr(const char* haystack, const char* needle, size_t len) {
  char c, sc;

  if ((c = *needle++) != 0) {
    c = ascii_tolower(c);
    size_t needle_len = strlen(needle);
    do {
      do {
        if (len-- <= needle_len
            || 0 == (sc = *haystack++))
          return nullptr;
      } while (ascii_tolower(sc) != c);
    } while (strncasecmp(haystack, needle, needle_len) != 0);
    haystack--;
  }
  return haystack;
}

// ----------------------------------------------------------------------
// gstrncasestr is a case-insensitive strnstr.
//    Finds the occurence of the (null-terminated) needle in the
//    haystack, where no more than len bytes of haystack is searched.
//    Characters that appear after a '\0' in the haystack are not searched.
//
//    This function uses ascii_tolower() instead of tolower(), for speed.
// ----------------------------------------------------------------------
char *gstrncasestr(char* haystack, const char* needle, size_t len) {
  return const_cast<char *>(gstrncasestr(static_cast<const char *>(haystack),
                                         needle, len));
}
// ----------------------------------------------------------------------
// gstrncasestr_split performs a case insensitive search
// on (prefix, non_alpha, suffix).
// ----------------------------------------------------------------------
char *gstrncasestr_split(const char* str,
                         const char* prefix, char non_alpha,
                         const char* suffix,
                         size_t n) {
  int prelen = prefix == nullptr ? 0 : strlen(prefix);
  int suflen = suffix == nullptr ? 0 : strlen(suffix);

  // adjust the string and its length to avoid unnessary searching.
  // an added benefit is to avoid unnecessary range checks in the if
  // statement in the inner loop.
  if (suflen + prelen >= n)  return nullptr;
  str += prelen;
  n -= prelen;
  n -= suflen;

  const char* where = nullptr;

  // for every occurance of non_alpha in the string ...
  while ((where = static_cast<const char*>(
            memchr(str, non_alpha, n))) != nullptr) {
    // ... test whether it is followed by suffix and preceded by prefix
    if ((!suflen || strncasecmp(where + 1, suffix, suflen) == 0) &&
        (!prelen || strncasecmp(where - prelen, prefix, prelen) == 0)) {
      return const_cast<char*>(where - prelen);
    }
    // if not, advance the pointer, and adjust the length according
    n -= (where + 1) - str;
    str = where + 1;
  }

  return nullptr;
}

// ----------------------------------------------------------------------
// strcasestr_alnum is like a case-insensitive strstr, except that it
// ignores non-alphanumeric characters in both strings for the sake of
// comparison.
//
// This function uses ascii_isalnum() instead of isalnum() and
// ascii_tolower() instead of tolower(), for speed.
//
// E.g. strcasestr_alnum("i use google all the time", " !!Google!! ")
// returns pointer to "google all the time"
// ----------------------------------------------------------------------
char *strcasestr_alnum(const char *haystack, const char *needle) {
  const char *haystack_ptr;
  const char *needle_ptr;

  // Skip non-alnums at beginning
  while ( !ascii_isalnum(*needle) )
    if ( *needle++ == '\0' )
      return const_cast<char*>(haystack);
  needle_ptr = needle;

  // Skip non-alnums at beginning
  while ( !ascii_isalnum(*haystack) )
    if ( *haystack++ == '\0' )
      return nullptr;
  haystack_ptr = haystack;

  while ( *needle_ptr != '\0' ) {
    // Non-alnums - advance
    while ( !ascii_isalnum(*needle_ptr) )
      if ( *needle_ptr++ == '\0' )
        return const_cast<char *>(haystack);

    while ( !ascii_isalnum(*haystack_ptr) )
      if ( *haystack_ptr++ == '\0' )
        return nullptr;

    if ( ascii_tolower(*needle_ptr) == ascii_tolower(*haystack_ptr) ) {
      // Case-insensitive match - advance
      needle_ptr++;
      haystack_ptr++;
    } else {
      // No match - rollback to next start point in haystack
      haystack++;
      while ( !ascii_isalnum(*haystack) )
        if ( *haystack++ == '\0' )
          return nullptr;
      haystack_ptr = haystack;
      needle_ptr = needle;
    }
  }
  return const_cast<char *>(haystack);
}

// ----------------------------------------------------------------------
// CountSubstring()
//    Return the number times a "substring" appears in the "text"
//    NOTE: this function's complexity is O(|text| * |substring|)
//          It is meant for short "text" (such as to ensure the
//          printf format string has the right number of arguments).
//          DO NOT pass in long "text".
// ----------------------------------------------------------------------
int CountSubstring(StringPiece text, StringPiece substring) {
  CHECK_GT(substring.length(), 0);

  int count = 0;
  StringPiece::size_type curr = 0;
  while (StringPiece::npos != (curr = text.find(substring, curr))) {
    ++count;
    ++curr;
  }
  return count;
}

// ----------------------------------------------------------------------
// strstr_delimited()
//    Just like strstr(), except it ensures that the needle appears as
//    a complete item (or consecutive series of items) in a delimited
//    list.
//
//    Like strstr(), returns haystack if needle is empty, or NULL if
//    either needle/haystack is NULL.
// ----------------------------------------------------------------------
const char* strstr_delimited(const char* haystack,
                             const char* needle,
                             char delim) {
  if (!needle || !haystack) return nullptr;
  if (*needle == '\0') return haystack;

  int needle_len = strlen(needle);

  while (true) {
    // Skip any leading delimiters.
    while (*haystack == delim) ++haystack;

    // Walk down the haystack, matching every character in the needle.
    const char* this_match = haystack;
    int i = 0;
    for (; i < needle_len; i++) {
      if (*haystack != needle[i]) {
        // We ran out of haystack or found a non-matching character.
        break;
      }
      ++haystack;
    }

    // If we matched the whole needle, ensure that it's properly delimited.
    if (i == needle_len && (*haystack == '\0' || *haystack == delim)) {
      return this_match;
    }

    // No match. Consume non-delimiter characters until we run out of them.
    while (*haystack != delim) {
      if (*haystack == '\0') return nullptr;
      ++haystack;
    }
  }
  LOG(FATAL) << "Unreachable statement";
  return nullptr;
}

// ----------------------------------------------------------------------
// Older versions of libc have a buggy strsep.
// ----------------------------------------------------------------------

char* gstrsep(char** stringp, const char* delim) {
  char *s;
  const char *spanp;
  int c, sc;
  char *tok;

  if ((s = *stringp) == nullptr)
    return nullptr;

  tok = s;
  while (true) {
    c = *s++;
    spanp = delim;
    do {
      if ((sc = *spanp++) == c) {
        if (c == 0)
          s = nullptr;
        else
          s[-1] = 0;
        *stringp = s;
        return tok;
      }
    } while (sc != 0);
  }

  return nullptr; /* should not happen */
}

void FastStringAppend(string* s, const char* data, int len) {
  STLAppendToString(s, data, len);
}

// TODO(user): add a microbenchmark and revisit
// the optimizations done here.
//
// Several converters use this table to reduce
// division and modulo operations.
extern const char two_ASCII_digits[100][2];

const char two_ASCII_digits[100][2] = {
  {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'},
  {'0', '5'}, {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'},
  {'1', '0'}, {'1', '1'}, {'1', '2'}, {'1', '3'}, {'1', '4'},
  {'1', '5'}, {'1', '6'}, {'1', '7'}, {'1', '8'}, {'1', '9'},
  {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'}, {'2', '4'},
  {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
  {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'},
  {'3', '5'}, {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'},
  {'4', '0'}, {'4', '1'}, {'4', '2'}, {'4', '3'}, {'4', '4'},
  {'4', '5'}, {'4', '6'}, {'4', '7'}, {'4', '8'}, {'4', '9'},
  {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'}, {'5', '4'},
  {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
  {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'},
  {'6', '5'}, {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'},
  {'7', '0'}, {'7', '1'}, {'7', '2'}, {'7', '3'}, {'7', '4'},
  {'7', '5'}, {'7', '6'}, {'7', '7'}, {'7', '8'}, {'7', '9'},
  {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'}, {'8', '4'},
  {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
  {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'},
  {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}
};

static inline void PutTwoDigits(int i, char* p) {
  DCHECK_GE(i, 0);
  DCHECK_LT(i, 100);
  p[0] = two_ASCII_digits[i][0];
  p[1] = two_ASCII_digits[i][1];
}

char* FastTimeToBuffer(time_t s, char* buffer) {
  if (s == 0) {
    time(&s);
  }

  struct tm tm;
  if (PortableSafeGmtime(&s, &tm) == nullptr) {
    // Error message must fit in 30-char buffer.
    memcpy(buffer, "Invalid:", sizeof("Invalid:"));
    FastInt64ToBufferLeft(s, buffer+strlen(buffer));
    return buffer;
  }

  // strftime format: "%a, %d %b %Y %H:%M:%S GMT",
  // but strftime does locale stuff which we do not want
  // plus strftime takes > 10x the time of hard code

  const char* weekday_name = "Xxx";
  switch (tm.tm_wday) {
    default: { DLOG(FATAL) << "tm.tm_wday: " << tm.tm_wday; } break;
    case 0:  weekday_name = "Sun"; break;
    case 1:  weekday_name = "Mon"; break;
    case 2:  weekday_name = "Tue"; break;
    case 3:  weekday_name = "Wed"; break;
    case 4:  weekday_name = "Thu"; break;
    case 5:  weekday_name = "Fri"; break;
    case 6:  weekday_name = "Sat"; break;
  }

  const char* month_name = "Xxx";
  switch (tm.tm_mon) {
    default:  { DLOG(FATAL) << "tm.tm_mon: " << tm.tm_mon; } break;
    case 0:   month_name = "Jan"; break;
    case 1:   month_name = "Feb"; break;
    case 2:   month_name = "Mar"; break;
    case 3:   month_name = "Apr"; break;
    case 4:   month_name = "May"; break;
    case 5:   month_name = "Jun"; break;
    case 6:   month_name = "Jul"; break;
    case 7:   month_name = "Aug"; break;
    case 8:   month_name = "Sep"; break;
    case 9:   month_name = "Oct"; break;
    case 10:  month_name = "Nov"; break;
    case 11:  month_name = "Dec"; break;
  }

  // Write out the buffer.

  memcpy(buffer+0, weekday_name, 3);
  buffer[3] = ',';
  buffer[4] = ' ';

  PutTwoDigits(tm.tm_mday, buffer+5);
  buffer[7] = ' ';

  memcpy(buffer+8, month_name, 3);
  buffer[11] = ' ';

  int32 year = tm.tm_year + 1900;
  PutTwoDigits(year/100, buffer+12);
  PutTwoDigits(year%100, buffer+14);
  buffer[16] = ' ';

  PutTwoDigits(tm.tm_hour, buffer+17);
  buffer[19] = ':';

  PutTwoDigits(tm.tm_min, buffer+20);
  buffer[22] = ':';

  PutTwoDigits(tm.tm_sec, buffer+23);

  // includes ending NUL
  memcpy(buffer+25, " GMT", 5);

  return buffer;
}

// ----------------------------------------------------------------------
// strdup_with_new()
// strndup_with_new()
//
//    strdup_with_new() is the same as strdup() except that the memory
//    is allocated by new[] and hence an exception will be generated
//    if out of memory.
//
//    strndup_with_new() is the same as strdup_with_new() except that it will
//    copy up to the specified number of characters.  This function
//    is useful when we want to copy a substring out of a string
//    and didn't want to (or cannot) modify the string
// ----------------------------------------------------------------------
char* strdup_with_new(const char* the_string) {
  if (the_string == nullptr)
    return nullptr;
  else
    return strndup_with_new(the_string, strlen(the_string));
}

char* strndup_with_new(const char* the_string, int max_length) {
  if (the_string == nullptr)
    return nullptr;

  auto result = new char[max_length + 1];
  result[max_length] = '\0';  // terminate the string because strncpy might not
  return strncpy(result, the_string, max_length);
}

// ----------------------------------------------------------------------
// ScanForFirstWord()
//    This function finds the first word in the string "the_string" given.
//    A word is defined by consecutive !ascii_isspace() characters.
//    If no valid words are found,
//        return NULL and *end_ptr will contain junk
//    else
//        return the beginning of the first word and
//        *end_ptr will store the address of the first invalid character
//        (ascii_isspace() or '\0').
//
//    Precondition: (end_ptr != NULL)
// ----------------------------------------------------------------------
const char* ScanForFirstWord(const char* the_string, const char** end_ptr) {
  CHECK(end_ptr != nullptr) << ": precondition violated";

  if (the_string == nullptr)  // empty string
    return nullptr;

  const char* curr = the_string;
  while ((*curr != '\0') && ascii_isspace(*curr))  // skip initial spaces
    ++curr;

  if (*curr == '\0')  // no valid word found
    return nullptr;

  // else has a valid word
  const char* first_word = curr;

  // now locate the end of the word
  while ((*curr != '\0') && !ascii_isspace(*curr))
    ++curr;

  *end_ptr = curr;
  return first_word;
}

// ----------------------------------------------------------------------
// AdvanceIdentifier()
//    This function returns a pointer past the end of the longest C-style
//    identifier that is a prefix of str or NULL if str does not start with
//    one.  A C-style identifier begins with an ASCII letter or underscore
//    and continues with ASCII letters, digits, or underscores.
// ----------------------------------------------------------------------
const char *AdvanceIdentifier(const char *str) {
  // Not using isalpha and isalnum so as not to rely on the locale.
  // We could have used ascii_isalpha and ascii_isalnum.
  char ch = *str++;
  if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'))
    return nullptr;
  while (true) {
    ch = *str;
    if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
          (ch >= '0' && ch <= '9') || ch == '_'))
      return str;
    str++;
  }
}

// ----------------------------------------------------------------------
// IsIdentifier()
//    This function returns true if str is a C-style identifier.
//    A C-style identifier begins with an ASCII letter or underscore
//    and continues with ASCII letters, digits, or underscores.
// ----------------------------------------------------------------------
bool IsIdentifier(const char *str) {
  const char *end = AdvanceIdentifier(str);
  return end && *end == '\0';
}

static bool IsWildcard(Rune character) {
  return character == '*' || character == '?';
}

// Move the strings pointers to the point where they start to differ.
template <typename CHAR, typename NEXT>
static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end,
                         const CHAR** string, const CHAR* string_end,
                         NEXT next) {
  const CHAR* escape = nullptr;
  while (*pattern != pattern_end && *string != string_end) {
    if (!escape && IsWildcard(**pattern)) {
      // We don't want to match wildcard here, except if it's escaped.
      return;
    }

    // Check if the escapement char is found. If so, skip it and move to the
    // next character.
    if (!escape && **pattern == '\\') {
      escape = *pattern;
      next(pattern, pattern_end);
      continue;
    }

    // Check if the chars match, if so, increment the ptrs.
    const CHAR* pattern_next = *pattern;
    const CHAR* string_next = *string;
    Rune pattern_char = next(&pattern_next, pattern_end);
    if (pattern_char == next(&string_next, string_end) &&
        pattern_char != Runeerror &&
        pattern_char <= Runemax) {
      *pattern = pattern_next;
      *string = string_next;
    } else {
      // Uh ho, it did not match, we are done. If the last char was an
      // escapement, that means that it was an error to advance the ptr here,
      // let's put it back where it was. This also mean that the MatchPattern
      // function will return false because if we can't match an escape char
      // here, then no one will.
      if (escape) {
        *pattern = escape;
      }
      return;
    }

    escape = nullptr;
  }
}

template <typename CHAR, typename NEXT>
static void EatWildcard(const CHAR** pattern, const CHAR* end, NEXT next) {
  while (*pattern != end) {
    if (!IsWildcard(**pattern))
      return;
    next(pattern, end);
  }
}

template <typename CHAR, typename NEXT>
static bool MatchPatternT(const CHAR* eval, const CHAR* eval_end,
                          const CHAR* pattern, const CHAR* pattern_end,
                          int depth,
                          NEXT next) {
  const int kMaxDepth = 16;
  if (depth > kMaxDepth)
    return false;

  // Eat all the matching chars.
  EatSameChars(&pattern, pattern_end, &eval, eval_end, next);

  // If the string is empty, then the pattern must be empty too, or contains
  // only wildcards.
  if (eval == eval_end) {
    EatWildcard(&pattern, pattern_end, next);
    return pattern == pattern_end;
  }

  // Pattern is empty but not string, this is not a match.
  if (pattern == pattern_end)
    return false;

  // If this is a question mark, then we need to compare the rest with
  // the current string or the string with one character eaten.
  const CHAR* next_pattern = pattern;
  next(&next_pattern, pattern_end);
  if (pattern[0] == '?') {
    if (MatchPatternT(eval, eval_end, next_pattern, pattern_end,
                      depth + 1, next))
      return true;
    const CHAR* next_eval = eval;
    next(&next_eval, eval_end);
    if (MatchPatternT(next_eval, eval_end, next_pattern, pattern_end,
                      depth + 1, next))
      return true;
  }

  // This is a *, try to match all the possible substrings with the remainder
  // of the pattern.
  if (pattern[0] == '*') {
    // Collapse duplicate wild cards (********** into *) so that the
    // method does not recurse unnecessarily. http://crbug.com/52839
    EatWildcard(&next_pattern, pattern_end, next);

    while (eval != eval_end) {
      if (MatchPatternT(eval, eval_end, next_pattern, pattern_end,
                        depth + 1, next))
        return true;
      eval++;
    }

    // We reached the end of the string, let see if the pattern contains only
    // wildcards.
    if (eval == eval_end) {
      EatWildcard(&pattern, pattern_end, next);
      if (pattern != pattern_end)
        return false;
      return true;
    }
  }

  return false;
}

struct NextCharUTF8 {
  Rune operator()(const char** p, const char* end) {
    Rune c;
    int offset = charntorune(&c, *p, static_cast<int>(end - *p));
    *p += offset;
    return c;
  }
};

bool MatchPattern(const StringPiece& eval,
                  const StringPiece& pattern) {
  return MatchPatternT(eval.data(), eval.data() + eval.size(),
                       pattern.data(), pattern.data() + pattern.size(),
                       0, NextCharUTF8());
}

// ----------------------------------------------------------------------
// FindTagValuePair
//    Given a string of the form
//    <something><attr_sep><tag><tag_value_sep><value><attr_sep>...<string_term>
//    where the part before the first attr_sep is optional,
//    this function extracts the first tag and value, if any.
//    The function returns true if successful, in which case "tag" and "value"
//    are set to point to the beginning of the tag and the value, respectively,
//    and "tag_len" and "value_len" are set to the respective lengths.
// ----------------------------------------------------------------------

bool FindTagValuePair(const char* arg_str, char tag_value_separator,
                      char attribute_separator, char string_terminal,
                      char **tag, int *tag_len,
                      char **value, int *value_len) {
  char* in_str = const_cast<char*>(arg_str);  // For msvc8.
  if (in_str == nullptr)
    return false;
  char tv_sep_or_term[3] = {tag_value_separator, string_terminal, '\0'};
  char attr_sep_or_term[3] = {attribute_separator, string_terminal, '\0'};

  // Look for beginning of tag
  *tag = strpbrk(in_str, attr_sep_or_term);
  // If string_terminal is '\0', strpbrk won't find it but return null.
  if (*tag == nullptr || **tag == string_terminal)
    *tag = in_str;
  else
    (*tag)++;   // Move past separator
  // Now look for value...
  char *tv_sep_pos = strpbrk(*tag, tv_sep_or_term);
  if (tv_sep_pos == nullptr || *tv_sep_pos == string_terminal)
    return false;
  // ...and end of value
  char *attr_sep_pos = strpbrk(tv_sep_pos, attr_sep_or_term);

  *tag_len = tv_sep_pos - *tag;
  *value = tv_sep_pos + 1;
  if (attr_sep_pos != nullptr)
    *value_len = attr_sep_pos - *value;
  else
    *value_len = strlen(*value);
  return true;
}

void UniformInsertString(string* s, int interval, const char* separator) {
  const size_t separator_len = strlen(separator);

  if (interval < 1 ||      // invalid interval
      s->empty() ||        // nothing to do
      separator_len == 0)  // invalid separator
    return;

  int num_inserts = (s->size() - 1) / interval;  // -1 to avoid appending at end
  if (num_inserts == 0)  // nothing to do
    return;

  string tmp;
  tmp.reserve(s->size() + num_inserts * separator_len + 1);

  for (int i = 0; i < num_inserts ; ++i) {
    // append this interval
    tmp.append(*s, i * interval, interval);
    // append a separator
    tmp.append(separator, separator_len);
  }

  // append the tail
  const size_t tail_pos = num_inserts * interval;
  tmp.append(*s, tail_pos, s->size() - tail_pos);

  s->swap(tmp);
}

void InsertString(string *const s,
                  const vector<uint32> &indices,
                  char const *const separator) {
  const unsigned num_indices(indices.size());
  if (num_indices == 0) {
    return;  // nothing to do...
  }

  const unsigned separator_len(strlen(separator));
  if (separator_len == 0) {
    return;  // still nothing to do...
  }

  string tmp;
  const unsigned s_len(s->size());
  tmp.reserve(s_len + separator_len * num_indices);

  vector<uint32>::const_iterator const ind_end(indices.end());
  auto ind_pos(indices.begin());

  uint32 last_pos(0);
  while (ind_pos != ind_end) {
    const uint32 pos(*ind_pos);
    DCHECK_GE(pos, last_pos);
    DCHECK_LE(pos, s_len);

    tmp.append(s->substr(last_pos, pos - last_pos));
    tmp.append(separator);

    last_pos = pos;
    ++ind_pos;
  }
  tmp.append(s->substr(last_pos));

  s->swap(tmp);
}

//------------------------------------------------------------------------
// FindNth()
//  return index of nth occurrence of c in the string,
//  or string::npos if n > number of occurrences of c.
//  (returns string::npos = -1 if n <= 0)
//------------------------------------------------------------------------
int FindNth(StringPiece s, char c, int n) {
  size_t pos = string::npos;

  for ( int i = 0; i < n; ++i ) {
    pos = s.find_first_of(c, pos + 1);
    if ( pos == StringPiece::npos ) {
      break;
    }
  }
  return pos;
}

//------------------------------------------------------------------------
// ReverseFindNth()
//  return index of nth-to-last occurrence of c in the string,
//  or string::npos if n > number of occurrences of c.
//  (returns string::npos if n <= 0)
//------------------------------------------------------------------------
int ReverseFindNth(StringPiece s, char c, int n) {
  if ( n <= 0 ) {
    return static_cast<int>(StringPiece::npos);
  }

  size_t pos = s.size();

  for ( int i = 0; i < n; ++i ) {
    // If pos == 0, we return StringPiece::npos right away. Otherwise,
    // the following find_last_of call would take (pos - 1) as string::npos,
    // which means it would again search the entire input string.
    if (pos == 0) {
      return static_cast<int>(StringPiece::npos);
    }
    pos = s.find_last_of(c, pos - 1);
    if ( pos == string::npos ) {
      break;
    }
  }
  return pos;
}

namespace strings {

// FindEol()
// Returns the location of the next end-of-line sequence.

StringPiece FindEol(StringPiece s) {
  for (size_t i = 0; i < s.length(); ++i) {
    if (s[i] == '\n') {
      return StringPiece(s.data() + i, 1);
    }
    if (s[i] == '\r') {
      if (i+1 < s.length() && s[i+1] == '\n') {
        return StringPiece(s.data() + i, 2);
      } else {
        return StringPiece(s.data() + i, 1);
      }
    }
  }
  return StringPiece(s.data() + s.length(), 0);
}

}  // namespace strings

//------------------------------------------------------------------------
// OnlyWhitespace()
//  return true if string s contains only whitespace characters
//------------------------------------------------------------------------
bool OnlyWhitespace(const StringPiece& s) {
  for (const auto& c : s) {
    if ( !ascii_isspace(c) ) return false;
  }
  return true;
}

string PrefixSuccessor(const StringPiece& prefix) {
  // We can increment the last character in the string and be done
  // unless that character is 255, in which case we have to erase the
  // last character and increment the previous character, unless that
  // is 255, etc. If the string is empty or consists entirely of
  // 255's, we just return the empty string.
  bool done = false;
  string limit(prefix.data(), prefix.size());
  int index = limit.length() - 1;
  while (!done && index >= 0) {
    if (limit[index] == 255) {
      limit.erase(index);
      index--;
    } else {
      limit[index]++;
      done = true;
    }
  }
  if (!done) {
    return "";
  } else {
    return limit;
  }
}

string ImmediateSuccessor(const StringPiece& s) {
  // Return the input string, with an additional NUL byte appended.
  string out;
  out.reserve(s.size() + 1);
  out.append(s.data(), s.size());
  out.push_back('\0');
  return out;
}

void FindShortestSeparator(const StringPiece& start,
                           const StringPiece& limit,
                           string* separator) {
  // Find length of common prefix
  size_t min_length = min(start.size(), limit.size());
  size_t diff_index = 0;
  while ((diff_index < min_length) &&
         (start[diff_index] == limit[diff_index])) {
    diff_index++;
  }

  if (diff_index >= min_length) {
    // Handle the case where either string is a prefix of the other
    // string, or both strings are identical.
    start.CopyToString(separator);
    return;
  }

  if (diff_index+1 == start.size()) {
    // If the first difference is in the last character, do not bother
    // incrementing that character since the separator will be no
    // shorter than "start".
    start.CopyToString(separator);
    return;
  }

  if (start[diff_index] == 0xff) {
    // Avoid overflow when incrementing start[diff_index]
    start.CopyToString(separator);
    return;
  }

  separator->assign(start.data(), diff_index);
  separator->push_back(start[diff_index] + 1);
  if (*separator >= limit) {
    // Never pick a separator that causes confusion with "limit"
    start.CopyToString(separator);
  }
}

int SafeSnprintf(char *str, size_t size, const char *format, ...) {
  va_list printargs;
  va_start(printargs, format);
  int ncw = vsnprintf(str, size, format, printargs);
  va_end(printargs);
  return (ncw < size && ncw >= 0) ? ncw : 0;
}

bool GetlineFromStdioFile(FILE* file, string* str, char delim) {
  str->erase();
  while (true) {
    if (feof(file) || ferror(file)) {
      return false;
    }
    int c = getc(file);
    if (c == EOF) return false;
    if (c == delim) return true;
    str->push_back(c);
  }
}

namespace {

template <typename CHAR>
size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
  for (size_t i = 0; i < dst_size; ++i) {
    if ((dst[i] = src[i]) == 0)  // We hit and copied the terminating NULL.
      return i;
  }

  // We were left off at dst_size.  We over copied 1 byte.  Null terminate.
  if (dst_size != 0)
    dst[dst_size - 1] = 0;

  // Count the rest of the |src|, and return it's length in characters.
  while (src[dst_size]) ++dst_size;
  return dst_size;
}

}  // namespace

size_t strings::strlcpy(char* dst, const char* src, size_t dst_size) {
  return lcpyT<char>(dst, src, dst_size);
}


text:
title:  "Zašto je potrebno tumačenje?"
date:   02/05/2020
---

>

> "A bez vjere nemoguće mu je ugoditi, jer onaj koji želi pristupiti Bogu mora vjerovati da postoji Bog i da nagrađuje one koji ga traže." (Hebrejima 11,6)

### Biblijski tekstovi
Luka 24,36-45; 1. Korinćanima 12,10; 1. Korinćanima 14,26; Djela 17,16-32; Ivan 12,42.43.

Čitati Bibliju istodobno znači tumačiti je. Ali kako se to radi? Koja se načela primjenjuju? Kako razumjeti različite vrste štiva koja tu nalazimo? Na primjer, je li odlomak koji čitamo usporedba, proročkosimbolički san ili iznošenje povijesti? Već sama odluka o tako važnom pitanju u vezi s kontekstom Svetog pisma obuhvaća i čin tumačenja.

Ljudi katkad koriste Bibliju kao neku vrstu božanskog proročišta — nasumično je otvore da bi potražili neki redak za koji misle da će ih uputiti u dobrom smjeru. Međutim, nasumično povezivanje biblijskih tekstova onako kako nailazimo na njih, može nas dovesti do vrlo čudnih i pogrešnih zaključaka.

Na primjer, jedna žena koju je muž napustio zbog druge, osjetila se vrlo ohrabrenom kad je pronašla sljedeći redak: "Neprijateljstvo ja zamećem između tebe i žene." (Postanak 3,15) Na osnovi tog retka bila je uvjerena da afera njezinog muža neće potrajati!

Bilo koji redak izvučen iz konteksta lako postaje izgovor za provođenje vlastitih planova i zamisli. Prema tome, Bibliju trebamo ne samo čitati, već je i ispravno tumačiti.

*OIKOS: Ovog tjedna čitamo iz knjige Ellen G. White,Velika borba, Znaci vremena, 2010., poglavlje 35*


text:
package reconciliation

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/kubernetes/pkg/apis/rbac"
	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/rbac/internalversion"
)

// +k8s:deepcopy-gen=true
// +k8s:deepcopy-gen:interfaces=k8s.io/kubernetes/pkg/registry/rbac/reconciliation.RuleOwner
// +k8s:deepcopy-gen:nonpointer-interfaces=true
type ClusterRoleRuleOwner struct {
	ClusterRole *rbac.ClusterRole
}

func (o ClusterRoleRuleOwner) GetObject() runtime.Object {
	return o.ClusterRole
}

func (o ClusterRoleRuleOwner) GetNamespace() string {
	return o.ClusterRole.Namespace
}

func (o ClusterRoleRuleOwner) GetName() string {
	return o.ClusterRole.Name
}

func (o ClusterRoleRuleOwner) GetLabels() map[string]string {
	return o.ClusterRole.Labels
}

func (o ClusterRoleRuleOwner) SetLabels(in map[string]string) {
	o.ClusterRole.Labels = in
}

func (o ClusterRoleRuleOwner) GetAnnotations() map[string]string {
	return o.ClusterRole.Annotations
}

func (o ClusterRoleRuleOwner) SetAnnotations(in map[string]string) {
	o.ClusterRole.Annotations = in
}

func (o ClusterRoleRuleOwner) GetRules() []rbac.PolicyRule {
	return o.ClusterRole.Rules
}

func (o ClusterRoleRuleOwner) SetRules(in []rbac.PolicyRule) {
	o.ClusterRole.Rules = in
}

func (o ClusterRoleRuleOwner) GetAggregationRule() *rbac.AggregationRule {
	return o.ClusterRole.AggregationRule
}

func (o ClusterRoleRuleOwner) SetAggregationRule(in *rbac.AggregationRule) {
	o.ClusterRole.AggregationRule = in
}

type ClusterRoleModifier struct {
	Client internalversion.ClusterRoleInterface
}

func (c ClusterRoleModifier) Get(namespace, name string) (RuleOwner, error) {
	ret, err := c.Client.Get(name, metav1.GetOptions{})
	if err != nil {
		return nil, err
	}
	return ClusterRoleRuleOwner{ClusterRole: ret}, err
}

func (c ClusterRoleModifier) Create(in RuleOwner) (RuleOwner, error) {
	ret, err := c.Client.Create(in.(ClusterRoleRuleOwner).ClusterRole)
	if err != nil {
		return nil, err
	}
	return ClusterRoleRuleOwner{ClusterRole: ret}, err
}

func (c ClusterRoleModifier) Update(in RuleOwner) (RuleOwner, error) {
	ret, err := c.Client.Update(in.(ClusterRoleRuleOwner).ClusterRole)
	if err != nil {
		return nil, err
	}
	return ClusterRoleRuleOwner{ClusterRole: ret}, err

}


text:
"use strict";

var routes = require("../app/routes");
var eventAggregator = require("../app/event");

module.exports = {
    homeHandler: function() {
        eventAggregator.trigger("set:route", routes.home);
    },

    aboutHandler: function() {
        eventAggregator.trigger("set:route", routes.about);
    }
};