text:
namespace exec {
namespace user {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_User_2eproto();
void protobuf_AssignDesc_User_2eproto();
void protobuf_ShutdownFile_User_2eproto();

class Property;
class UserProperties;
class UserToBitHandshake;
class RequestResults;
class RunQuery;
class BitToUserHandshake;

enum RpcType {
  HANDSHAKE = 0,
  ACK = 1,
  GOODBYE = 2,
  RUN_QUERY = 3,
  CANCEL_QUERY = 4,
  REQUEST_RESULTS = 5,
  RESUME_PAUSED_QUERY = 11,
  QUERY_DATA = 6,
  QUERY_HANDLE = 7,
  REQ_META_FUNCTIONS = 8,
  RESP_FUNCTION_LIST = 9,
  QUERY_RESULT = 10
};
bool RpcType_IsValid(int value);
const RpcType RpcType_MIN = HANDSHAKE;
const RpcType RpcType_MAX = RESUME_PAUSED_QUERY;
const int RpcType_ARRAYSIZE = RpcType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
inline const ::std::string& RpcType_Name(RpcType value) {
  return ::google::protobuf::internal::NameOfEnum(
    RpcType_descriptor(), value);
}
inline bool RpcType_Parse(
    const ::std::string& name, RpcType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RpcType>(
    RpcType_descriptor(), name, value);
}
enum QueryResultsMode {
  STREAM_FULL = 1
};
bool QueryResultsMode_IsValid(int value);
const QueryResultsMode QueryResultsMode_MIN = STREAM_FULL;
const QueryResultsMode QueryResultsMode_MAX = STREAM_FULL;
const int QueryResultsMode_ARRAYSIZE = QueryResultsMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor();
inline const ::std::string& QueryResultsMode_Name(QueryResultsMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryResultsMode_descriptor(), value);
}
inline bool QueryResultsMode_Parse(
    const ::std::string& name, QueryResultsMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryResultsMode>(
    QueryResultsMode_descriptor(), name, value);
}
enum HandshakeStatus {
  SUCCESS = 1,
  RPC_VERSION_MISMATCH = 2,
  AUTH_FAILED = 3,
  UNKNOWN_FAILURE = 4
};
bool HandshakeStatus_IsValid(int value);
const HandshakeStatus HandshakeStatus_MIN = SUCCESS;
const HandshakeStatus HandshakeStatus_MAX = UNKNOWN_FAILURE;
const int HandshakeStatus_ARRAYSIZE = HandshakeStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor();
inline const ::std::string& HandshakeStatus_Name(HandshakeStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    HandshakeStatus_descriptor(), value);
}
inline bool HandshakeStatus_Parse(
    const ::std::string& name, HandshakeStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HandshakeStatus>(
    HandshakeStatus_descriptor(), name, value);
}
// ===================================================================

class Property : public ::google::protobuf::Message {
 public:
  Property();
  virtual ~Property();

  Property(const Property& from);

  inline Property& operator=(const Property& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Property& default_instance();

  void Swap(Property* other);

  // implements Message ----------------------------------------------

  Property* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Property& from);
  void MergeFrom(const Property& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string key = 1;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 1;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const char* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // required string value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  inline void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:exec.user.Property)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_value();
  inline void clear_has_value();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* key_;
  ::std::string* value_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static Property* default_instance_;
};
// -------------------------------------------------------------------

class UserProperties : public ::google::protobuf::Message {
 public:
  UserProperties();
  virtual ~UserProperties();

  UserProperties(const UserProperties& from);

  inline UserProperties& operator=(const UserProperties& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserProperties& default_instance();

  void Swap(UserProperties* other);

  // implements Message ----------------------------------------------

  UserProperties* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserProperties& from);
  void MergeFrom(const UserProperties& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.user.Property properties = 1;
  inline int properties_size() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 1;
  inline const ::exec::user::Property& properties(int index) const;
  inline ::exec::user::Property* mutable_properties(int index);
  inline ::exec::user::Property* add_properties();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
      properties() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
      mutable_properties();

  // @@protoc_insertion_point(class_scope:exec.user.UserProperties)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::Property > properties_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserProperties* default_instance_;
};
// -------------------------------------------------------------------

class UserToBitHandshake : public ::google::protobuf::Message {
 public:
  UserToBitHandshake();
  virtual ~UserToBitHandshake();

  UserToBitHandshake(const UserToBitHandshake& from);

  inline UserToBitHandshake& operator=(const UserToBitHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UserToBitHandshake& default_instance();

  void Swap(UserToBitHandshake* other);

  // implements Message ----------------------------------------------

  UserToBitHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserToBitHandshake& from);
  void MergeFrom(const UserToBitHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  inline bool has_channel() const;
  inline void clear_channel();
  static const int kChannelFieldNumber = 1;
  inline ::exec::shared::RpcChannel channel() const;
  inline void set_channel(::exec::shared::RpcChannel value);

  // optional bool support_listening = 2;
  inline bool has_support_listening() const;
  inline void clear_support_listening();
  static const int kSupportListeningFieldNumber = 2;
  inline bool support_listening() const;
  inline void set_support_listening(bool value);

  // optional int32 rpc_version = 3;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 3;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.shared.UserCredentials credentials = 4;
  inline bool has_credentials() const;
  inline void clear_credentials();
  static const int kCredentialsFieldNumber = 4;
  inline const ::exec::shared::UserCredentials& credentials() const;
  inline ::exec::shared::UserCredentials* mutable_credentials();
  inline ::exec::shared::UserCredentials* release_credentials();
  inline void set_allocated_credentials(::exec::shared::UserCredentials* credentials);

  // optional .exec.user.UserProperties properties = 5;
  inline bool has_properties() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 5;
  inline const ::exec::user::UserProperties& properties() const;
  inline ::exec::user::UserProperties* mutable_properties();
  inline ::exec::user::UserProperties* release_properties();
  inline void set_allocated_properties(::exec::user::UserProperties* properties);

  // optional bool support_complex_types = 6 [default = false];
  inline bool has_support_complex_types() const;
  inline void clear_support_complex_types();
  static const int kSupportComplexTypesFieldNumber = 6;
  inline bool support_complex_types() const;
  inline void set_support_complex_types(bool value);

  // optional bool support_timeout = 7 [default = false];
  inline bool has_support_timeout() const;
  inline void clear_support_timeout();
  static const int kSupportTimeoutFieldNumber = 7;
  inline bool support_timeout() const;
  inline void set_support_timeout(bool value);

  // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
 private:
  inline void set_has_channel();
  inline void clear_has_channel();
  inline void set_has_support_listening();
  inline void clear_has_support_listening();
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_credentials();
  inline void clear_has_credentials();
  inline void set_has_properties();
  inline void clear_has_properties();
  inline void set_has_support_complex_types();
  inline void clear_has_support_complex_types();
  inline void set_has_support_timeout();
  inline void clear_has_support_timeout();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int channel_;
  ::google::protobuf::int32 rpc_version_;
  ::exec::shared::UserCredentials* credentials_;
  ::exec::user::UserProperties* properties_;
  bool support_listening_;
  bool support_complex_types_;
  bool support_timeout_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserToBitHandshake* default_instance_;
};
// -------------------------------------------------------------------

class RequestResults : public ::google::protobuf::Message {
 public:
  RequestResults();
  virtual ~RequestResults();

  RequestResults(const RequestResults& from);

  inline RequestResults& operator=(const RequestResults& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RequestResults& default_instance();

  void Swap(RequestResults* other);

  // implements Message ----------------------------------------------

  RequestResults* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestResults& from);
  void MergeFrom(const RequestResults& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.QueryId query_id = 1;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 1;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // optional int32 maximum_responses = 2;
  inline bool has_maximum_responses() const;
  inline void clear_maximum_responses();
  static const int kMaximumResponsesFieldNumber = 2;
  inline ::google::protobuf::int32 maximum_responses() const;
  inline void set_maximum_responses(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.RequestResults)
 private:
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_maximum_responses();
  inline void clear_has_maximum_responses();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  ::google::protobuf::int32 maximum_responses_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RequestResults* default_instance_;
};
// -------------------------------------------------------------------

class RunQuery : public ::google::protobuf::Message {
 public:
  RunQuery();
  virtual ~RunQuery();

  RunQuery(const RunQuery& from);

  inline RunQuery& operator=(const RunQuery& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RunQuery& default_instance();

  void Swap(RunQuery* other);

  // implements Message ----------------------------------------------

  RunQuery* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RunQuery& from);
  void MergeFrom(const RunQuery& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.user.QueryResultsMode results_mode = 1;
  inline bool has_results_mode() const;
  inline void clear_results_mode();
  static const int kResultsModeFieldNumber = 1;
  inline ::exec::user::QueryResultsMode results_mode() const;
  inline void set_results_mode(::exec::user::QueryResultsMode value);

  // optional .exec.shared.QueryType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::exec::shared::QueryType type() const;
  inline void set_type(::exec::shared::QueryType value);

  // optional string plan = 3;
  inline bool has_plan() const;
  inline void clear_plan();
  static const int kPlanFieldNumber = 3;
  inline const ::std::string& plan() const;
  inline void set_plan(const ::std::string& value);
  inline void set_plan(const char* value);
  inline void set_plan(const char* value, size_t size);
  inline ::std::string* mutable_plan();
  inline ::std::string* release_plan();
  inline void set_allocated_plan(::std::string* plan);

  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
 private:
  inline void set_has_results_mode();
  inline void clear_has_results_mode();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_plan();
  inline void clear_has_plan();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int results_mode_;
  int type_;
  ::std::string* plan_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RunQuery* default_instance_;
};
// -------------------------------------------------------------------

class BitToUserHandshake : public ::google::protobuf::Message {
 public:
  BitToUserHandshake();
  virtual ~BitToUserHandshake();

  BitToUserHandshake(const BitToUserHandshake& from);

  inline BitToUserHandshake& operator=(const BitToUserHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BitToUserHandshake& default_instance();

  void Swap(BitToUserHandshake* other);

  // implements Message ----------------------------------------------

  BitToUserHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BitToUserHandshake& from);
  void MergeFrom(const BitToUserHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 rpc_version = 2;
  inline bool has_rpc_version() const;
  inline void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 2;
  inline ::google::protobuf::int32 rpc_version() const;
  inline void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.user.HandshakeStatus status = 3;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 3;
  inline ::exec::user::HandshakeStatus status() const;
  inline void set_status(::exec::user::HandshakeStatus value);

  // optional string errorId = 4;
  inline bool has_errorid() const;
  inline void clear_errorid();
  static const int kErrorIdFieldNumber = 4;
  inline const ::std::string& errorid() const;
  inline void set_errorid(const ::std::string& value);
  inline void set_errorid(const char* value);
  inline void set_errorid(const char* value, size_t size);
  inline ::std::string* mutable_errorid();
  inline ::std::string* release_errorid();
  inline void set_allocated_errorid(::std::string* errorid);

  // optional string errorMessage = 5;
  inline bool has_errormessage() const;
  inline void clear_errormessage();
  static const int kErrorMessageFieldNumber = 5;
  inline const ::std::string& errormessage() const;
  inline void set_errormessage(const ::std::string& value);
  inline void set_errormessage(const char* value);
  inline void set_errormessage(const char* value, size_t size);
  inline ::std::string* mutable_errormessage();
  inline ::std::string* release_errormessage();
  inline void set_allocated_errormessage(::std::string* errormessage);

  // @@protoc_insertion_point(class_scope:exec.user.BitToUserHandshake)
 private:
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_errorid();
  inline void clear_has_errorid();
  inline void set_has_errormessage();
  inline void clear_has_errormessage();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 rpc_version_;
  int status_;
  ::std::string* errorid_;
  ::std::string* errormessage_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static BitToUserHandshake* default_instance_;
};
// ===================================================================

// ===================================================================

// Property

// required string key = 1;
inline bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Property::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& Property::key() const {
  return *key_;
}
inline void Property::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* Property::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// required string value = 2;
inline bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Property::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& Property::value() const {
  return *value_;
}
inline void Property::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* Property::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_value(::std::string* value) {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (value) {
    set_has_value();
    value_ = value;
  } else {
    clear_has_value();
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// UserProperties

// repeated .exec.user.Property properties = 1;
inline int UserProperties::properties_size() const {
  return properties_.size();
}
inline void UserProperties::clear_properties() {
  properties_.Clear();
}
inline const ::exec::user::Property& UserProperties::properties(int index) const {
  return properties_.Get(index);
}
inline ::exec::user::Property* UserProperties::mutable_properties(int index) {
  return properties_.Mutable(index);
}
inline ::exec::user::Property* UserProperties::add_properties() {
  return properties_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
UserProperties::properties() const {
  return properties_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
UserProperties::mutable_properties() {
  return &properties_;
}

// -------------------------------------------------------------------

// UserToBitHandshake

// optional .exec.shared.RpcChannel channel = 1 [default = USER];
inline bool UserToBitHandshake::has_channel() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserToBitHandshake::set_has_channel() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UserToBitHandshake::clear_has_channel() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UserToBitHandshake::clear_channel() {
  channel_ = 2;
  clear_has_channel();
}
inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const {
  return static_cast< ::exec::shared::RpcChannel >(channel_);
}
inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) {
  assert(::exec::shared::RpcChannel_IsValid(value));
  set_has_channel();
  channel_ = value;
}

// optional bool support_listening = 2;
inline bool UserToBitHandshake::has_support_listening() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserToBitHandshake::set_has_support_listening() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UserToBitHandshake::clear_has_support_listening() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UserToBitHandshake::clear_support_listening() {
  support_listening_ = false;
  clear_has_support_listening();
}
inline bool UserToBitHandshake::support_listening() const {
  return support_listening_;
}
inline void UserToBitHandshake::set_support_listening(bool value) {
  set_has_support_listening();
  support_listening_ = value;
}

// optional int32 rpc_version = 3;
inline bool UserToBitHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserToBitHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UserToBitHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UserToBitHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const {
  return rpc_version_;
}
inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.shared.UserCredentials credentials = 4;
inline bool UserToBitHandshake::has_credentials() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserToBitHandshake::set_has_credentials() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UserToBitHandshake::clear_has_credentials() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UserToBitHandshake::clear_credentials() {
  if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
  clear_has_credentials();
}
inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const {
  return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() {
  set_has_credentials();
  if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials;
  return credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() {
  clear_has_credentials();
  ::exec::shared::UserCredentials* temp = credentials_;
  credentials_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) {
  delete credentials_;
  credentials_ = credentials;
  if (credentials) {
    set_has_credentials();
  } else {
    clear_has_credentials();
  }
}

// optional .exec.user.UserProperties properties = 5;
inline bool UserToBitHandshake::has_properties() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserToBitHandshake::set_has_properties() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UserToBitHandshake::clear_has_properties() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UserToBitHandshake::clear_properties() {
  if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
  clear_has_properties();
}
inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const {
  return properties_ != NULL ? *properties_ : *default_instance_->properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() {
  set_has_properties();
  if (properties_ == NULL) properties_ = new ::exec::user::UserProperties;
  return properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() {
  clear_has_properties();
  ::exec::user::UserProperties* temp = properties_;
  properties_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) {
  delete properties_;
  properties_ = properties;
  if (properties) {
    set_has_properties();
  } else {
    clear_has_properties();
  }
}

// optional bool support_complex_types = 6 [default = false];
inline bool UserToBitHandshake::has_support_complex_types() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UserToBitHandshake::set_has_support_complex_types() {
  _has_bits_[0] |= 0x00000020u;
}
inline void UserToBitHandshake::clear_has_support_complex_types() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void UserToBitHandshake::clear_support_complex_types() {
  support_complex_types_ = false;
  clear_has_support_complex_types();
}
inline bool UserToBitHandshake::support_complex_types() const {
  return support_complex_types_;
}
inline void UserToBitHandshake::set_support_complex_types(bool value) {
  set_has_support_complex_types();
  support_complex_types_ = value;
}

// optional bool support_timeout = 7 [default = false];
inline bool UserToBitHandshake::has_support_timeout() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UserToBitHandshake::set_has_support_timeout() {
  _has_bits_[0] |= 0x00000040u;
}
inline void UserToBitHandshake::clear_has_support_timeout() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void UserToBitHandshake::clear_support_timeout() {
  support_timeout_ = false;
  clear_has_support_timeout();
}
inline bool UserToBitHandshake::support_timeout() const {
  return support_timeout_;
}
inline void UserToBitHandshake::set_support_timeout(bool value) {
  set_has_support_timeout();
  support_timeout_ = value;
}

// -------------------------------------------------------------------

// RequestResults

// optional .exec.shared.QueryId query_id = 1;
inline bool RequestResults::has_query_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RequestResults::set_has_query_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RequestResults::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RequestResults::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& RequestResults::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* RequestResults::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* RequestResults::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// optional int32 maximum_responses = 2;
inline bool RequestResults::has_maximum_responses() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RequestResults::set_has_maximum_responses() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RequestResults::clear_has_maximum_responses() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RequestResults::clear_maximum_responses() {
  maximum_responses_ = 0;
  clear_has_maximum_responses();
}
inline ::google::protobuf::int32 RequestResults::maximum_responses() const {
  return maximum_responses_;
}
inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) {
  set_has_maximum_responses();
  maximum_responses_ = value;
}

// -------------------------------------------------------------------

// RunQuery

// optional .exec.user.QueryResultsMode results_mode = 1;
inline bool RunQuery::has_results_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RunQuery::set_has_results_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RunQuery::clear_has_results_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RunQuery::clear_results_mode() {
  results_mode_ = 1;
  clear_has_results_mode();
}
inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
}
inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
  assert(::exec::user::QueryResultsMode_IsValid(value));
  set_has_results_mode();
  results_mode_ = value;
}

// optional .exec.shared.QueryType type = 2;
inline bool RunQuery::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RunQuery::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RunQuery::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RunQuery::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::exec::shared::QueryType RunQuery::type() const {
  return static_cast< ::exec::shared::QueryType >(type_);
}
inline void RunQuery::set_type(::exec::shared::QueryType value) {
  assert(::exec::shared::QueryType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string plan = 3;
inline bool RunQuery::has_plan() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RunQuery::set_has_plan() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RunQuery::clear_has_plan() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RunQuery::clear_plan() {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    plan_->clear();
  }
  clear_has_plan();
}
inline const ::std::string& RunQuery::plan() const {
  return *plan_;
}
inline void RunQuery::set_plan(const ::std::string& value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value, size_t size) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RunQuery::mutable_plan() {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  return plan_;
}
inline ::std::string* RunQuery::release_plan() {
  clear_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = plan_;
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RunQuery::set_allocated_plan(::std::string* plan) {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (plan) {
    set_has_plan();
    plan_ = plan;
  } else {
    clear_has_plan();
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// BitToUserHandshake

// optional int32 rpc_version = 2;
inline bool BitToUserHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BitToUserHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BitToUserHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BitToUserHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const {
  return rpc_version_;
}
inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.user.HandshakeStatus status = 3;
inline bool BitToUserHandshake::has_status() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BitToUserHandshake::set_has_status() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BitToUserHandshake::clear_has_status() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BitToUserHandshake::clear_status() {
  status_ = 1;
  clear_has_status();
}
inline ::exec::user::HandshakeStatus BitToUserHandshake::status() const {
  return static_cast< ::exec::user::HandshakeStatus >(status_);
}
inline void BitToUserHandshake::set_status(::exec::user::HandshakeStatus value) {
  assert(::exec::user::HandshakeStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional string errorId = 4;
inline bool BitToUserHandshake::has_errorid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BitToUserHandshake::set_has_errorid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BitToUserHandshake::clear_has_errorid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BitToUserHandshake::clear_errorid() {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    errorid_->clear();
  }
  clear_has_errorid();
}
inline const ::std::string& BitToUserHandshake::errorid() const {
  return *errorid_;
}
inline void BitToUserHandshake::set_errorid(const ::std::string& value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value, size_t size) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errorid() {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  return errorid_;
}
inline ::std::string* BitToUserHandshake::release_errorid() {
  clear_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errorid_;
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errorid(::std::string* errorid) {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    delete errorid_;
  }
  if (errorid) {
    set_has_errorid();
    errorid_ = errorid;
  } else {
    clear_has_errorid();
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string errorMessage = 5;
inline bool BitToUserHandshake::has_errormessage() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BitToUserHandshake::set_has_errormessage() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BitToUserHandshake::clear_has_errormessage() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BitToUserHandshake::clear_errormessage() {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    errormessage_->clear();
  }
  clear_has_errormessage();
}
inline const ::std::string& BitToUserHandshake::errormessage() const {
  return *errormessage_;
}
inline void BitToUserHandshake::set_errormessage(const ::std::string& value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value, size_t size) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errormessage() {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  return errormessage_;
}
inline ::std::string* BitToUserHandshake::release_errormessage() {
  clear_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errormessage_;
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errormessage) {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    delete errormessage_;
  }
  if (errormessage) {
    set_has_errormessage();
    errormessage_ = errormessage;
  } else {
    clear_has_errormessage();
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace user
}  // namespace exec

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RpcType>() {
  return ::exec::user::RpcType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryResultsMode>() {
  return ::exec::user::QueryResultsMode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::HandshakeStatus>() {
  return ::exec::user::HandshakeStatus_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_User_2eproto__INCLUDED


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Braun, Mouchacca & McKenzie, N. Z. Jl Bot. 37(2): 317 (1999)

#### Original name
Pseudocercospora musicola U. Braun

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
class Action:
    def __init__(self, name, file, irc):
        # import an action module
        try:
            import eval('actions/' + file)
        except:
            exit()

        # return a list of terms the action uses
        # this is expected to be overridden by the child class
        def get_terms():
            pass

        # receive a command | {user: '', channel: '', term: '', message: ''}
        # send any responses or IRC actions directly to the IRC object
        # this is expected to be overridden by the child class
        def receive(message):
            pass

# link command received to the coresponding action
# (chan, term) -> action
# action.receive({user: '', channel: '', term: '', message: ''})
class Route_Actions:
    # initialize
    def __init__(self):
        # key tuple (chan, act): value action
        self.routes = {}

    # receive a list of actions and call the appropriate action's receive function
    def receive_actions(self, messages):
        for x in messages:
            chan = x['channel']
            term = x['term']
            self.routes[(chan, term)].receive(x)

    # remove all routing for a given action
    def remove_action(self, act):
        self.routes = {key: value for key, value in self.routes if value != act}

    # remove one instance of a route
    def remove_route(self, chan, term):
        self.routes[(chan, term)].pop()

    # set routes from a list of terms for a channel
    def set_route(self, chan, terms, act):
        for x in terms:
            self.routes[(chan, x)] = act


text:
huffdecoditication::huffdecoditication(char *FileInput)
{
    this->FileObjectInput = FileInput;
    File* FileObjectInput =new File(this->FileObjectInput);
    BitVector bitVector= BitVector();
    bitVector.setbit(QString().setNum(FileObjectInput->readFile(0),2),8);
    bitVector.setbit(QString().setNum(FileObjectInput->readFile(1),2),8);
    bitVector.setbit(QString().setNum(FileObjectInput->readFile(2),2),8);
    this->trash=0;
    this->sizeTree=0;
    this->sizeName=0;
    for(int i=2;i>=0;i--)
    {
        this->trash+=pow(2,2-i)*bitVector.bitVectorAt(i);
    }
    for(int i=15;i>=3;i--)
    {
        this->sizeTree+=pow(2,15-i)*bitVector.bitVectorAt(i);
    }
    for(int i=23;i>=16;i--)
    {
        this->sizeName+=pow(2,23-i)*bitVector.bitVectorAt(i);
    }
    this->fileName=FileObjectInput->readFile(3,this->sizeName);
    for(int i=3+this->sizeName;i<3+this->sizeName+this->sizeTree;i++)
    {
        this->treeRepresetation.append(FileObjectInput->readFile(i));
    }
    this->position=3+this->sizeName+this->sizeTree;
    FileObjectInput->setPosition(this->position);
    this->isEndBool=false;
}
QString huffdecoditication::TreeRepresetation()
{
    return this->treeRepresetation;
}
bool huffdecoditication::IsEnd()
{
    return this->isEndBool;
}
QString huffdecoditication::grabBucked()
{
    int read;
    std::ifstream inputFile;
    inputFile.open(this->FileObjectInput,std::ios::binary);
    if(inputFile.is_open())
    {
        inputFile.seekg(0,inputFile.end);
        sizeFile=inputFile.tellg();
        inputFile.seekg(0, inputFile.beg);
    }
    inputFile.seekg(this->position);
    if(sizeFile-position>5)
    {
        this->position+=MAX_SIZE_BUCKED;
        read=MAX_SIZE_BUCKED;
        this->isEndBool=false;
    }
    else
    {
        read=sizeFile-position;
        this->isEndBool=true;
    }
    QString file;
    char buff;
    for(int i=0;i<read;i++)
    {
        inputFile.get(buff);
        if(buff<0)
            file.append(buff+256);
        else
            file.append(buff);
    }
    return file;
}
bool huffdecoditication::isElement(cell* node,QString HuffmanCodification)
{
    bool boolReturn;
    if(HuffmanCodification.size()!=0)
    {
        if(node->leaf != true)
        {
            if(HuffmanCodification.at(0).toLatin1()=='0')
            {
                boolReturn=isElement(node->left, HuffmanCodification.remove(0,1));
            }
            if(HuffmanCodification.at(0).toLatin1()=='1')
            {
                boolReturn=isElement(node->right,HuffmanCodification.remove(0,1));
            }
        }
        if(node->leaf)
        {
            return true;
        }
    }
    else
        return false;
}
char huffdecoditication::getElementTree(cell* node,QString HuffmanCodification)
{
    char charReturn;
    if(node->leaf != true)
    {
        if(HuffmanCodification.at(0).toLatin1()=='0')
        {
            charReturn=isElement(node->left, HuffmanCodification.remove(0,1));
        }
        if(HuffmanCodification.at(0).toLatin1()=='1')
        {
            charReturn=isElement(node->right,HuffmanCodification.remove(0,1));
        }
    }
    if(node->leaf)
    {
        return node->getElement();
    }
}
int huffdecoditication::getTrash()
{
    return this->trash;
}
int huffdecoditication::getSize()
{
    return this->sizeFile;
}

cell* huffdecoditication::generation(QString Tree)
{
    cell* Left;
    cell* Right;
    QString TreeLeft=TreeHuffmanDecodificationLeft(Tree);
    QString TreeRight=TreeHuffmanDecodificationRight(Tree);
    if(TreeLeft.size()>1)
    {
        Left = generation(TreeLeft);
    }
    else
    {
        Left=new cell(TreeLeft.at(0).toLatin1(),0);
    }
    if(TreeRight.size()>1)
    {
        Right = generation(TreeRight);
    }
    else
    {
        Right = new cell(TreeRight.at(0).toLatin1(),0);
    }
    return new cell(0,Left,Right);
}
QString huffdecoditication::TreeHuffmanDecodificationLeft(QString huff)
{
    QList<char> test;
    QString TreeHuffmanDecodificationLeft;
    if(huff.at(0).toLatin1()=='(')
    {
        test.push_back('(');
        for(int i=1;i<huff.size();i++)
        {
            if(huff.at(i).toLatin1()=='(' && huff.at(i-1).toLatin1()!='-')
            {
                test.push_back('(');
            }
            if(huff.at(i).toLatin1()==')' && huff.at(i-1).toLatin1()!='-')
            {
                test.pop_back();
            }
            if(test.isEmpty())
            {
                break;
            }
            TreeHuffmanDecodificationLeft.append(huff.at(i));
        }
    }
    else
    {
        TreeHuffmanDecodificationLeft=huff.at(0);
        if(huff.at(0).toLatin1()=='-')
        {
            TreeHuffmanDecodificationLeft=huff.at(1);
        }
    }

    return TreeHuffmanDecodificationLeft;
}
QString huffdecoditication::TreeHuffmanDecodificationRight(QString huff)
{
    QList<char> test;
    QString TreeHuffmanDecodificationLeft;
    if(huff.at(0).toLatin1()=='(')
    {
        test.push_back('(');
        TreeHuffmanDecodificationLeft.append(')');
        for(int i=1;i<huff.size();i++)
        {
            if(huff.at(i).toLatin1()=='(' && huff.at(i-1).toLatin1()!='-')
            {
                test.push_back('(');
            }
            if(huff.at(i).toLatin1()==')' && huff.at(i-1).toLatin1()!='-')
            {
                test.pop_back();
            }
            TreeHuffmanDecodificationLeft.append(huff.at(i));
            if(test.isEmpty())
            {
                break;
            }
        }
    }
    else
    {
        TreeHuffmanDecodificationLeft=huff.at(0);
        if(huff.at(0).toLatin1()=='-')
        {
            TreeHuffmanDecodificationLeft.append(huff.at(1).toLatin1());
        }
    }
    QString TreeHuffmanDecodificationRight;
    huff.remove(0,TreeHuffmanDecodificationLeft.size());
    if(huff.at(0).toLatin1()=='(')
    {
        test.push_back('(');
        for(int i=1;i<huff.size();i++)
        {
            if(huff.at(i).toLatin1()=='(' && huff.at(i-1).toLatin1()!='-')
            {
                test.push_back('(');
            }
            if(huff.at(i).toLatin1()==')' && huff.at(i-1).toLatin1()!='-')
            {
                test.pop_back();
            }
            if(test.isEmpty())
            {
                break;
            }
           TreeHuffmanDecodificationRight.append(huff.at(i));
        }
    }
    else
    {
        TreeHuffmanDecodificationRight=huff.at(0);
        if(huff.at(0).toLatin1()=='-')
        {
            TreeHuffmanDecodificationRight=huff.at(1);
        }
    }

    return TreeHuffmanDecodificationRight;
}

char* huffdecoditication::getFileName()
{
    return this->fileName.toLocal8Bit().data();
}


text:
class NamespaceValidator < ActiveModel::EachValidator
  RESERVED = %w(
    admin
    all
    assets
    ci
    dashboard
    files
    groups
    help
    hooks
    issues
    merge_requests
    notes
    profile
    projects
    public
    repository
    s
    search
    services
    snippets
    teams
    u
    unsubscribes
    users
  ).freeze

  def validate_each(record, attribute, value)
    unless value =~ Gitlab::Regex.namespace_regex
      record.errors.add(attribute, Gitlab::Regex.namespace_regex_message)
    end

    if reserved?(value)
      record.errors.add(attribute, "#{value} is a reserved name")
    end
  end

  private

  def reserved?(value)
    RESERVED.include?(value)
  end
end


text:
package me.amanj.splittimer.util;

/**
 * Created by Amanj Sherwany on 8/4/16.
 */

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class TimeInformation implements Cloneable, Serializable {
    private List<Long> laps;
    private String name;
    private long storingTime;

    public TimeInformation() {
        this.laps = new ArrayList<>(50);
    }

    public TimeInformation(String name, long storingTime) {
        this.name = name;
        this.storingTime = storingTime;
        this.laps = new ArrayList<>(50);
    }

    public long getAverageTime() {
        return laps.size() <= 0? 0 : getElapsedTime() / laps.size();
    }

    public long getFastest() {
        if(laps.size() == 0) return 0l;
        long max = Long.MIN_VALUE;
        for(Long lap: laps) if(max < lap) max = lap;
        return max;
    }
    public long getSlowest() {
        if(laps.size() == 0) return 0l;
        long min = Long.MAX_VALUE;
        for(Long lap: laps) if(min > lap) min = lap;
        return min;
    }

    public void addLap(long time) {
        laps.add(time);
    }

    public void setName(String name) { this.name = name; }
    public void setStoringTime(long storingTime) {
        this.storingTime = storingTime;
    }
    public void setLaps(List<Long> laps) { this.laps = laps; }

    public String getName() { return name; }
    public List<Long> getLaps() { return laps; }
    public long getStoringTime() { return storingTime; }

    public void mergeLaps(int fIndex, int sIndex) {
        int size = laps.size();
        if(fIndex >= 0 && fIndex == sIndex - 1 && sIndex < size) {
            long lap2 = laps.remove(sIndex);
            long lap1 = laps.get(fIndex);
            laps.set(fIndex, lap1 + lap2);
        }
    }

    public long lapAt(int i) { return laps.get(i); }

    public long elapsedTimeAt(int i) {
        long elapsed = 0l;
        for(int j = 0; j <= i; j++) elapsed += laps.get(j);
        return elapsed;
    }

    public void clearLaps() { laps.clear(); }

    public int countLaps() { return laps.size(); }

    public long getElapsedTime() {
        long elapsed = 0;
        for(Long lap: laps) elapsed += lap;
        return elapsed;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Name: ");
        builder.append(name);
        builder.append(", Saving time: ");
        builder.append(storingTime);
        builder.append(", ");
        builder.append(laps.toString());
        return builder.toString();
    }

    public Object clone() {
        List<Long> laps = (List<Long>) ((ArrayList<Long>) this.laps).clone();
        TimeInformation res = new TimeInformation(this.name, this.storingTime);
        res.setLaps(laps);
        return res;
    }
}


text:
package org.springframework.cloud.client;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;

/**
 * Provides a more succinct conditional spring.cloud.discovery.enabled.
 *
 * @since 2.0
 * @author Olga Maciaszek-Sharma
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@ConditionalOnProperty(value = "spring.cloud.discovery.enabled", matchIfMissing = true)
public @interface ConditionalOnDiscoveryEnabled {

}


text:
var _ = require('underscore-cdb-v3');
var cdb = require('cartodb.js-v3');
cdb.admin = require('cdb.admin');
var $ = require('jquery-cdb-v3');
var bytesToSize = require('../../view_helpers/bytes_to_size');

/**
 * The content of the dropdown menu opened by the user avatar in the top-right of the header, e.g.:
 *   Explore, Learn, ♞
 *             ______/\____
 *            |            |
 *            |    this    |
 *            |____________|
 */
module.exports = cdb.admin.DropdownMenu.extend({
  className: 'Dropdown',

  initialize: function () {
    this.elder('initialize');
    if (!this.model) {
      throw new Error('model is required');
    }
    this.template_base = cdb.templates.getTemplate('common/views/dashboard_header/settings_dropdown');
  },

  shortDisplayName: function (user) {
    // This changes should also be done in Central, ./app/assets/javascripts/dashboard/users/views/user_avatar.js
    var accountTypeDisplayName = user.get('account_type_display_name');
    var displayName = _.isUndefined(accountTypeDisplayName) ? user.get('account_type') : accountTypeDisplayName;

    if (_.isUndefined(displayName)) {
      return displayName;
    }

    displayName = displayName.toLowerCase();

    if (displayName === 'organization user') {
      return 'org. user';
    } else {
      return displayName.replace(/lump-sum/gi, '- A')
        .replace(/academic/gi, 'aca.')
        .replace(/ - Monthly/i, ' - M')
        .replace(/ - Annual/i, ' - A')
        .replace(/Non-Profit/i, 'NP')
        .replace(/On-premises/i, 'OP')
        .replace(/Internal use engine/i, 'engine')
        .replace(/Lite/i, 'L')
        .replace(/Cloud Engine &/i, 'C. Engine &')
        .replace(/& Enterprise Builder/i, '& E. Builder')
        .replace(/CARTO for /i, '')
        .replace(/CARTO /i, '');
    }
  },

  render: function () {
    var user = this.model;
    var usedDataBytes = user.get('db_size_in_bytes');
    var quotaInBytes = user.get('quota_in_bytes');
    var usedDataPct = Math.round(usedDataBytes / quotaInBytes * 100);
    var progressBarClass = '';

    if (usedDataPct > 80 && usedDataPct < 90) {
      progressBarClass = 'is--inAlert';
    } else if (usedDataPct > 89) {
      progressBarClass = 'is--inDanger';
    }

    var accountType = this.shortDisplayName(user);

    var userUrl = this.model.viewUrl();
    var upgradeUrl = window.upgrade_url || cdb.config.get('upgrade_url') || '';

    this.$el.html(this.template_base({
      name: user.fullName() || user.get('username'),
      email: user.get('email'),
      accountType: accountType,
      isOrgAdmin: user.isOrgAdmin(),
      usedDataStr: bytesToSize(usedDataBytes).toString(2),
      usedDataPct: usedDataPct,
      progressBarClass: progressBarClass,
      availableDataStr: bytesToSize(quotaInBytes).toString(2),
      showUpgradeLink: upgradeUrl && (user.isOrgOwner() || !user.isInsideOrg()) && !cdb.config.get('cartodb_com_hosted'),
      upgradeUrl: upgradeUrl,
      publicProfileUrl: userUrl.publicProfile(),
      apiKeysUrl: userUrl.apiKeys(),
      organizationUrl: userUrl.organization(),
      accountProfileUrl: userUrl.accountProfile(),
      logoutUrl: userUrl.logout(),
      isViewer: user.isViewer(),
      isBuilder: user.isBuilder(),
      orgDisplayEmail: user.isInsideOrg() ? user.organization.display_email : null,
      engineEnabled: user.get('actions').engine_enabled,
      mobileAppsEnabled: user.get('actions').mobile_sdk_enabled
    }));

    // Necessary to hide dialog on click outside popup, for example.
    cdb.god.bind('closeDialogs', this.hide, this);

    // TODO: taken from existing code, how should dropdowns really be added to the DOM?
    $('body').append(this.el);

    return this;
  },

  clean: function () {
    // Until https://github.com/CartoDB/cartodb.js/issues/238 is resolved:
    $(this.options.target).unbind('click', this._handleClick);
    this.constructor.__super__.clean.apply(this);
  }

});


text:
package com.facebook.stetho.inspector.console;

import com.facebook.stetho.inspector.helper.ChromePeerManager;
import com.facebook.stetho.inspector.protocol.module.Console;

/**
 * Utility for reporting an event to the console
 */
public class CLog {
  public static void writeToConsole(
      ChromePeerManager chromePeerManager,
      Console.MessageLevel logLevel,
      Console.MessageSource messageSource,
      String messageText) {
  }

  public static void writeToConsole(
      Console.MessageLevel logLevel,
      Console.MessageSource messageSource,
      String messageText
  ) {

  }
}


text:
<%= getMessage("plugin") %> / <%= title %>

				Title	<%= title %>

				Version	<%= version ? version : 'Not defined' %>

				Type	<%= plugintype ? getMessage(plugintype) : 'Not defined' %>

« <%= getMessage("go-back") %>

<%if(typeof missingresources !== "undefined" && missingresources.length > 0 ) {%>
	<a href="#plugin/resources/<%= _id %>" class="btn btn-s btn-primary"> <%= getMessage("plugin-resources") %>
<%}%>


text:
package stats

import (
	"errors"
)

// Sum adds all the numbers of a slice together
func Sum(input Float64Data) (sum float64, err error) {

	if input.Len() == 0 {
		return 0, errors.New("Input must not be empty")
	}

	// Add em up
	for _, n := range input {
		sum += n
	}

	return sum, nil
}


text:
> Jul 18, 2016

- **Feature:** Add `prevState` as argument to `onLeave` hooks ([#3616])
- **Bugfix:** Fix when the `<Link>` `onClick` invariant runs ([#3636])

[v2.6.0]: https://github.com/reactjs/react-router/compare/v2.5.2...v2.6.0
[#3616]: https://github.com/reactjs/react-router/pull/3616
[#3636]: https://github.com/reactjs/react-router/pull/3636

## [v2.5.2]
> Jul 1, 2016

- **Bugfix:** Remove extraneous `propTypes` check when creating a route object from a React element ([#3591])

[v2.5.2]: https://github.com/reactjs/react-router/compare/v2.5.1...v2.5.2
[#3591]: https://github.com/reactjs/react-router/pull/3591

## [v2.5.1]
> Jun 23, 2016

- **Bugfix:** Throw error instead of silently failing with history v3 ([#3571])
- **Bugfix:** Explicitly throw error in `onClick` handler of `<Link>` rendered outside of router context ([#3572])

[v2.5.1]: https://github.com/reactjs/react-router/compare/v2.5.0...v2.5.1
[#3571]: https://github.com/reactjs/react-router/pull/3571
[#3572]: https://github.com/reactjs/react-router/pull/3572

## [v2.5.0]
> Jun 22, 2016

- **Feature/Deprecation:** Call `getChildRoutes` and `getIndexRoute` with `partialNextState`; deprecate accessing `location` directly in favor of `partialNextState.location` there ([#3556], [#3561], [#3569], [Upgrade Guide](/upgrade-guides/v2.5.0.md#getchildroutes-getindexroute-signature))
- **Refactor:** Refactor creating `routeParams` objects ([#3544])

[v2.5.0]: https://github.com/reactjs/react-router/compare/v2.4.1...v2.5.0
[#3544]: https://github.com/reactjs/react-router/pull/3544
[#3556]: https://github.com/reactjs/react-router/pull/3556
[#3561]: https://github.com/reactjs/react-router/pull/3561
[#3569]: https://github.com/reactjs/react-router/pull/3569

## [v2.4.1]
> May 19, 2016

- **Bugfix:** Don't crash on invalid URI components in params ([#3453])

[v2.4.1]: https://github.com/reactjs/react-router/compare/v2.4.0...v2.4.1
[#3453]: https://github.com/reactjs/react-router/pull/3453

## [v2.4.0]
> April 28, 2016

- **Feature:** Add `withRouter` higher-order component for injecting `props.router` ([#3352])
- **Minor:** Add React as a peer dependency ([#3361])
- **Minor:** Upgrade to Babel 6 ([#3362])
- **Minor:** Add `target` to `propTypes` for `<Link>` ([#3397])

[v2.4.0]: https://github.com/reactjs/react-router/compare/v2.3.0...v2.4.0
[#3352]: https://github.com/reactjs/react-router/pull/3352
[#3361]: https://github.com/reactjs/react-router/pull/3361
[#3362]: https://github.com/reactjs/react-router/pull/3362
[#3397]: https://github.com/reactjs/react-router/pull/3397

## [v2.3.0]
> April 18, 2016

- **Feature:** Add `applyRouterMiddleware` for extending router rendering ([#3327])
- **Feature/Deprecation:** Add `routerShape` and `locationShape` as top-level exported prop types, and deprecate all the old prop types, including the ones that were previously incorrectly removed ([#3349])
- **Minor:** Move ES module build back to `es6/` to avoid breaking people who were importing from `react-router/es6` ([#3334])

[v2.3.0]: https://github.com/reactjs/react-router/compare/v2.2.4...v2.3.0
[#3327]: https://github.com/reactjs/react-router/pull/3327
[#3334]: https://github.com/reactjs/react-router/pull/3334
[#3349]: https://github.com/reactjs/react-router/pull/3349

## [v2.2.4]
> April 15, 2016

- **Noop:** Publish again to npm to work around missing tarball problem

[v2.2.4]: https://github.com/reactjs/react-router/compare/v2.2.3...v2.2.4

## [v2.2.3]
> April 15, 2016

- **Bugfix:** Don't use `Object.assign` in `getComponentsForRoute` ([#3331])
- **Minor:** Speed up checking index path active status ([#3313])

[v2.2.3]: https://github.com/reactjs/react-router/compare/v2.2.2...v2.2.3
[#3331]: https://github.com/reactjs/react-router/pull/3331
[#3313]: https://github.com/reactjs/react-router/pull/3313

## [v2.2.2]
> April 14, 2016

- **Bugfix:** Fix edge cases with continuing matches after pathless routes ([#3308])

[v2.2.2]: https://github.com/reactjs/react-router/compare/v2.2.1...v2.2.2
[#3308]: https://github.com/reactjs/react-router/pull/3308

## [v2.2.1]
> April 14, 2016

- **Bugfix:** Fix `this` in `getComponent` and `getComponents` ([#3306])

[v2.2.1]: https://github.com/reactjs/react-router/compare/v2.2.0...v2.2.1
[#3306]: https://github.com/reactjs/react-router/pull/3306

## [v2.2.0]
> April 13, 2016

- **Feature/Deprecation:** Call `getComponent` and `getComponents` with `nextState`; deprecate accessing `location` directly in favor of `nextState.location` there ([#3298], [Upgrade Guide](/upgrade-guides/v2.2.0.md#getcomponent-getcomponents-signature))
- **Bugfix:** Do not ignore extraneous slashes in matching ([#3285])
- **Bugfix:** Do not unnecessarily set empty `className` on `<Link>` ([#3288])
- **Minor:** Update PropTypes ([#3218])
- **Minor:** Move ES module build from `es6/` to `es/` ([#3295])
- **Minor:** Do not include unused deprecation logic in production builds ([#3296])

[v2.2.0]: https://github.com/reactjs/react-router/compare/v2.1.1...v2.2.0
[#3218]: https://github.com/reactjs/react-router/pull/3218
[#3285]: https://github.com/reactjs/react-router/pull/3285
[#3288]: https://github.com/reactjs/react-router/pull/3288
[#3295]: https://github.com/reactjs/react-router/pull/3295
[#3296]: https://github.com/reactjs/react-router/pull/3296
[#3298]: https://github.com/reactjs/react-router/pull/3298

## [v2.1.1]
> April 11, 2016

- **Bugfix:** Remove unintentionally released code change ([#3280])

[v2.1.1]: https://github.com/reactjs/react-router/compare/v2.1.0...v2.1.1
[#3280]: https://github.com/reactjs/react-router/pull/3280

## [v2.1.0]
> April 11, 2016

- **Feature:** Add support for `onChange` hook on routes ([#3108])
- **Minor:** Include full warning messages in non-minified UMD build ([#3213])
- **Minor:** Speed up path matching ([#3217])

[v2.1.0]: https://github.com/reactjs/react-router/compare/v2.0.1...v2.1.0
[#3108]: https://github.com/reactjs/react-router/pull/3108
[#3213]: https://github.com/reactjs/react-router/pull/3213
[#3217]: https://github.com/reactjs/react-router/pull/3217

## [v2.0.1]
> March 9, 2016

- **Bugfix:** Call transition hooks on child routes of parents whose params
changed but the child's did not. ([#3166])
- **Minor:** Remove support for installing from source ([#3164])

[v2.0.1]: https://github.com/reactjs/react-router/compare/v2.0.0...v2.0.1
[#3164]: https://github.com/reactjs/react-router/pull/3164
[#3166]: https://github.com/reactjs/react-router/pull/3166

## [v2.0.0]
> Feb 10, 2016

- **Bugfix:** Add back basename support in `match` ([#3054])

[v2.0.0]: https://github.com/reactjs/react-router/compare/v2.0.0-rc6...v2.0.0
[#3054]: https://github.com/reactjs/react-router/pull/3054

## [v2.0.0-rc6]
> Feb 5, 2016

- **Breaking:** Removed default top-level `<Router>` export ([#2906])
- **Bugfix:** Use history.createLocation where possible ([#2910])
- **Bugfix:** Fix initial routing state after `match` ([#2965])
- **Minor:** Reduce stack size from matching routes ([#2923])

[v2.0.0-rc6]: https://github.com/reactjs/react-router/compare/v2.0.0-rc5...v2.0.0-rc6
[#2906]: https://github.com/reactjs/react-router/pull/2906
[#2910]: https://github.com/reactjs/react-router/pull/2910
[#2965]: https://github.com/reactjs/react-router/pull/2965
[#2923]: https://github.com/reactjs/react-router/pull/2923

## [v2.0.0-rc5]
> Jan 14, 2016

- **Feature:** Support custom `history` for `match` ([#2813])
- **Feature:** Support location descriptor in `replace` callback in `onEnter` ([#2855])
- **Feature:** Improve support for server rendering async routes ([#2883])

[v2.0.0-rc5]: https://github.com/reactjs/react-router/compare/v2.0.0-rc4...v2.0.0-rc5
[#2813]: https://github.com/reactjs/react-router/pull/2813
[#2855]: https://github.com/reactjs/react-router/pull/2855
[#2883]: https://github.com/reactjs/react-router/pull/2883

## [v2.0.0-rc4]
> Dec 30, 2015

- **Feature:** Added `render` prop to `Router`
- **Feature:** Added singleton `browserHistory` and `hashHistory`
- **Feature:** Added `createMemoryHistory`
- **Deprecation:** Deprecated all mixins
- **Deprecation:** Replaced `context.history` with `context.router`
- **Deprecation:** Deprecated Route Component `props.history`
- **Deprecation:** Deprecated `context.location`

[v2.0.0-rc4]: https://github.com/reactjs/react-router/compare/v1.0.3...v2.0.0-rc4

## [v1.0.3]
> Dec 23, 2015

- Switched back to a caret range for history, now that the warnings have been removed

[v1.0.3]: https://github.com/reactjs/react-router/compare/v1.0.2...v1.0.3

## [v1.0.2]
> Dec 8, 2015

- Pinned peer dependency on History to `1.13.x` to avoid console warnings.

[v1.0.2]: https://github.com/reactjs/react-router/compare/v1.0.1...v1.0.2

## [v1.0.1]
> Dec 5, 2015

- Support IE8 ([#2540])
- Add ES2015 module build ([#2530])

[v1.0.1]: https://github.com/reactjs/react-router/compare/v1.0.0...v1.0.1
[#2530]: https://github.com/reactjs/react-router/pull/2530
[#2540]: https://github.com/reactjs/react-router/pull/2540

## [v1.0.0]
> Nov 9, 2015

Please see `/upgrade-guides/v1.0.0.md`

[v1.0.0]: https://github.com/reactjs/react-router/compare/v0.13.5...v1.0.0


text:
<!doctype html>
<html><head>
            <title>DevFest</title>
            <meta name="description" content="">
            <meta name="keywords" content="">
            <meta name="generator" content="ORT - Ovh Redirect Technology">
            <meta name="url" content="https://sites.google.com/site/digitalculturedaysv2//">
            <meta name="robots" content="all">
        <style type="text/css"></style><style type="text/css"></style></head>
        <frameset rows="100%,0" frameborder="no" border="0">
            <frame name="ORT" src="https://sites.google.com/site/digitalculturedaysv2/">
            <frame name="NONE" src="" scrolling="no" noresize="">
            <noframes>
                &lt;body&gt;&lt;a href="https://sites.google.com/a/4planet.eu/digitalculturedays/"&gt;Click here&lt;/a&gt;&lt;hr&gt;&lt;/body&gt;
            </noframes>
        </frameset>
    </html>


text:
package com.hazelcast.simulator.coordinator;

import com.hazelcast.simulator.test.TestPhase;
import org.apache.log4j.Logger;

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import static java.lang.String.format;

public class TestPhaseListenerContainer {

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

    private final ConcurrentMap<Integer, TestPhaseListener> listenerMap = new ConcurrentHashMap<Integer, TestPhaseListener>();

    public Collection<TestPhaseListener> getListeners() {
        return listenerMap.values();
    }

    public void addListener(int testIndex, TestPhaseListener listener) {
        listenerMap.put(testIndex, listener);
    }

    public void updatePhaseCompletion(int testIndex, TestPhase testPhase) {
        TestPhaseListener listener = listenerMap.get(testIndex);
        if (listener == null) {
            LOGGER.error(format("Could not find listener for testIndex %d (%d listeners in total)", testIndex,
                    listenerMap.size()));
            return;
        }
        listener.completed(testPhase);
    }
}


text:
_[www.codever.land/bookmarks/t/writing-tools](https://www.codever.land/bookmarks/t/writing-tools)_
---
#### [Online Typing Test - Improve Your WPM Speed!](https://onlinetypingtests.com/)
_https://onlinetypingtests.com/_

Do you think you are a good typer? An average touch typer can type at around 60 WPM (word per minute). Find out how fast you are. Teach and Learn Typing, Free! Test & Improve your Typing Speed! We Pro...
* **tags**: [typescript](../tagged/typescript.md), [writing-tools](../tagged/writing-tools.md), [webmaster](../tagged/webmaster.md), [web-application](../tagged/web-application.md), [toolkit](../tagged/toolkit.md)
---
#### [Pandoc](http://pandoc.org/)
_http://pandoc.org/_

If you need to convert files from one markup format into another, pandoc is your swiss-army knife.
* **tags**: [dev-tools](../tagged/dev-tools.md), [writing-tools](../tagged/writing-tools.md)
---


text:
require 'ru_translit'

describe RuTranslit do
  before(:each) do
    @la_str = 'something'
    @cy_str = 'что-то'
    @cy_str2 = 'биографиями'
    @nr = '123'
  end

  it "should respond to the two main methods for transliteration and detransliteration" do
    RuTranslit.should respond_to('to_latin')
    RuTranslit.should respond_to('to_cyrillic')
  end

  it "should respond to some short or alternative forms for the two main methods" do
    RuTranslit.should respond_to('to_la')
    RuTranslit.should respond_to('to_cy')
    RuTranslit.should respond_to('transliterate')
    RuTranslit.should respond_to('detransliterate')
  end

  it "should return an array containing only the input when given a lowercase latin string to transliterate" do
    RuTranslit.to_latin(@la_str).should be_an_instance_of(Array)
    RuTranslit.to_latin(@la_str).should have(1).items
    RuTranslit.to_latin(@la_str).first.should == @la_str
  end

  it "should return an array containing only the input when given a lowercase cyrillic string to detransliterate" do
    RuTranslit.to_latin(@cy_str).should be_an_instance_of(Array)
    RuTranslit.to_latin(@cy_str).should have_at_least(1).items
    RuTranslit.to_cyrillic(@cy_str).first.should == @cy_str
  end

  it "should leave numbers alone in both directions" do
    RuTranslit.to_latin(@nr).should have(1).item
    RuTranslit.to_latin(@nr).first.should == @nr
    RuTranslit.to_cyrillic(@nr).should have(1).item
    RuTranslit.to_cyrillic(@nr).first.should == @nr
  end

  it "should preserve latin word-parts while transliterating cyrillic word-parts" do
    RuTranslit.to_latin(@cy_str + @la_str + @cy_str).first.should =~ /#{@la_str}/
  end

  it "should return a list of several transliterations for the russian word 'биографиями'" do
    RuTranslit.to_latin(@cy_str2).should have_at_least(2).items
    RuTranslit.to_latin(@cy_str2).should have_at_most(4).items #making sure it doesn't explode for some reason
  end

  it "should return (among others) the original input if we do a 'round-trip' cy->la->cy, using the first result" do
    RuTranslit.to_cyrillic(RuTranslit.to_latin(@cy_str2).first).should include(@cy_str2)
  end

  it "should return (among others) the original input if we do a 'round-trip' la->cy->la, using the first result" do
    RuTranslit.to_latin(RuTranslit.to_cyrillic(@la_str).first).should include(@la_str)
  end

  it "should offer cyrillic alternatives for 'schtsch', at least one of which should be only one letter long" do
    RuTranslit.to_cyrillic('schtsch').should include('щ')
  end

  it "should return different transliteration results depending on context in some cases" do
    RuTranslit.to_latin('де').should include('de')
    RuTranslit.to_latin('де').should_not include('dje')
    RuTranslit.to_latin('е').should include('je')
  end

  it "should include softeners in the detransliteration results (only) if called with the appropriate argument" do
    RuTranslit.to_cyrillic('f', false).should_not include('фь')
    RuTranslit.to_cyrillic('f', true).should include('фь')
  end

end


text:
ROOT = ../../../..
DIR = Executor/tests/Strlcat

include $(ROOT)/mak/config.mak

PROGRAM = TestStrlcat
SOURCES = TestStrlcat.c
EXTRA_INCLUDES += -I../../..

include ../common.mak
include $(ROOT)/mak/program.mak

tests:
	$(PROGRAM)

poststarttests:


text:
package name.valery1707.javadocBadge.version;

import java.util.Optional;

public interface VersionProvider {
	Optional<String> findActualVersion(String groupId, String versionId);
}


text:
import subprocess, sys

BUILD_MSBUILD_LIBS = False
VCVARSALL_PATH = '"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat"'
MSBUILD_PATH = '"C:\\program files (x86)\\msbuild\\14.0\\bin\\msbuild.exe"'
THIRDPARTY_PATH = '..\\3rdparty\\'

LIBJPEG_PROJ = '..\\3rdparty\\libjpeg\\build\\libjpegWin10\\libjpeg.vcxproj'
LIBXML_PROJ = '..\\3rdparty\\libxml2legacy\\Win10\\libxml2.Win10.vcxproj'
PIXMAN_PROJ = '..\\3rdparty\\pixmanlegacy\\Win10\\pixmanlegacy.Windows10\\pixmanlegacy.Windows10.vcxproj'
OPENAL_PROJ = '..\\3rdparty\\openal-soft-winphone\\winrt.vs2015\\OpenAL\\OpenAL.vcxproj'
CASSOWARY_PROJ = '..\\3rdparty\\cassowary-0.60\\cassowary-0.60-Windows.vcxproj'
LIBOBJC_PROJ = '..\\3rdparty\\libobjc2\\msvc\\libobjc2.vcxproj'
LIBDISPATCH_PROJ = '..\\3rdparty\\libdispatch\\build\\libdispatch.vcxproj'

RELEASE_X86 = '/p:Configuration=Release;Platform=x86'
RELEASE_X64 = '/p:Configuration=Release;Platform=x64'
RELEASE_ARM = '/p:Configuration=Release;Platform=ARM'
DEBUG_X86 = '/p:Configuration=Debug;Platform=x86'
DEBUG_X64 = '/p:Configuration=Debug;Platform=x64'
DEBUG_ARM = '/p:Configuration=Debug;Platform=ARM'

def run():
    if BUILD_MSBUILD_LIBS == True:
        subprocess.call(MSBUILD_PATH + ' ' + LIBJPEG_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBJPEG_PROJ + ' ' + RELEASE_X64)
        subprocess.call(MSBUILD_PATH + ' ' + LIBJPEG_PROJ + ' ' + RELEASE_ARM)

        subprocess.call(MSBUILD_PATH + ' ' + LIBXML_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBXML_PROJ + ' ' + RELEASE_X64)
        subprocess.call(MSBUILD_PATH + ' ' + LIBXML_PROJ + ' ' + RELEASE_ARM)

        subprocess.call(MSBUILD_PATH + ' ' + PIXMAN_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + PIXMAN_PROJ + ' ' + RELEASE_X64)
        subprocess.call(MSBUILD_PATH + ' ' + PIXMAN_PROJ + ' ' + RELEASE_ARM)

    print "Building freetype2"
    subprocess.call("python freetype2.py")
    print "Building zlib"
    subprocess.call("python zlib.py")
    print "Building libpng"
    subprocess.call("python libpng.py")

    print "Building cairo"
    subprocess.call(VCVARSALL_PATH + ' x86 && cairo.bat x86')
    subprocess.call(VCVARSALL_PATH + ' x86_x64 && cairo.bat x64')
    subprocess.call(VCVARSALL_PATH + ' x86_arm && cairo.bat arm')

    print "Building openssl"
    # Need to update openssl submodule
    #subprocess.call(".\openssl.bat ARM x86 x64")

    if BUILD_MSBUILD_LIBS == True:
        subprocess.call(MSBUILD_PATH + ' ' + OPENAL_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + OPENAL_PROJ + ' ' + RELEASE_X64)
        subprocess.call(MSBUILD_PATH + ' ' + OPENAL_PROJ + ' ' + RELEASE_ARM)

        subprocess.call(MSBUILD_PATH + ' ' + CASSOWARY_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + CASSOWARY_PROJ + ' ' + RELEASE_ARM)
        subprocess.call(MSBUILD_PATH + ' ' + CASSOWARY_PROJ + ' ' + DEBUG_X86)
        subprocess.call(MSBUILD_PATH + ' ' + CASSOWARY_PROJ + ' ' + DEBUG_ARM)

        subprocess.call(MSBUILD_PATH + ' ' + LIBOBJC_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBOBJC_PROJ + ' ' + RELEASE_ARM)
        subprocess.call(MSBUILD_PATH + ' ' + LIBOBJC_PROJ + ' ' + DEBUG_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBOBJC_PROJ + ' ' + DEBUG_ARM)

        subprocess.call(MSBUILD_PATH + ' ' + LIBDISPATCH_PROJ + ' ' + RELEASE_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBDISPATCH_PROJ + ' ' + RELEASE_ARM)
        subprocess.call(MSBUILD_PATH + ' ' + LIBDISPATCH_PROJ + ' ' + DEBUG_X86)
        subprocess.call(MSBUILD_PATH + ' ' + LIBDISPATCH_PROJ + ' ' + DEBUG_ARM)

if __name__ == "__main__":
    if len(sys.argv) > 1:
        if sys.argv[1] == '1' or sys.argv[1] == 'true' or sys.argv[1] == 'True':
            BUILD_MSBUILD_LIBS = True;
    run()


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">钻石迷情</string>
</resources>


text:
package ru.job4j.search;

import java.util.ArrayList;
import java.util.List;

/**
 * PhoneDictionary.
 * @author Ivan Belyaev
 * @since 24.04.2018
 * @version 1.0
 */
public class PhoneDictionary {
    /** List of people. */
    private List<Person> persons = new ArrayList<Person>();

    /**
     * The method adds a person to the phone dictionary.
     * @param person - the person you want to add.
     */
    public void add(Person person) {
        this.persons.add(person);
    }

    /**
     * The method returns a list of all users that contain the key in any fields.
     * @param key - search key.
     * @return returns a list of all users that contain the key in any fields.
     */
    public List<Person> find(String key) {
        List<Person> result = new ArrayList<>();

        for (Person person : persons) {
            if (person.getName().contains(key) || person.getSurname().contains(key)
                    || person.getPhone().contains(key) || person.getAddress().contains(key)) {
                result.add(person);
            }
        }

        return result;
    }
}


text:
package ie.cit.caf.lc_assignment;

import ie.cit.caf.lc_assignment.repository.ChObjectRepository;
import ie.cit.caf.lc_assignment.repository.ImagesRepository;
import ie.cit.caf.lc_assignment.repository.ParticipantsRepository;
import ie.cit.caf.lc_assignment.rowmapper.ChObjectRowMapper;
import ie.cit.caf.lc_assignment.rowmapper.ParticipantsRowMapper;
import ie.cit.caf.lc_assignment.service.ChObjectService;
import ie.cit.caf.lc_assignment.service.ImagesService;
import ie.cit.caf.lc_assignment.service.ParticipantsService;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.JdbcTemplate;

@SpringBootApplication
public class JdbcTemplateTestApplication implements CommandLineRunner{

	@Autowired
	JdbcTemplate jdbcTemplate;

	@Autowired
	ChObjectRepository chObjectRepository;

	@Autowired
	ChObjectService chObjectService;

	@Autowired
	ParticipantsRepository participantsRepository;

	@Autowired
	ParticipantsService paticipantsService;

	@Autowired
	ImagesRepository imagesRepository;

	@Autowired
	ImagesService imagesService;

	@Override
	public void run(String... arg0) throws Exception {
		query01();
		query02();
		query03();
		query04();
		/*query05();*/
		/*repositoryExample();*/
	}

    public static void main(String[] args) {
        SpringApplication.run(JdbcTemplateTestApplication.class, args);

    }

    public void query01() {
    	// Query for a list of maps with key-value pairs
    	// The hard way!!!

    	System.out.println("\nQuery 1 (List all objects using resultset Map)\n----------------");

    	String sql = "SELECT * FROM chObject";
    	List<Map<String, Object>> resultSet = jdbcTemplate.queryForList(sql);

    	for (Map<String, Object> row : resultSet) {
    		System.out.println("\nTitle: " + row.get("title"));
    		System.out.println("\nID: " + row.get("id"));
    		System.out.println("\nDate: " + row.get("date"));
    		System.out.println("\nMedium:  " + row.get("medium"));
    		System.out.println("\nCreditLine: " + row.get("creditline"));
    		System.out.println("\nDescription: " + row.get("description"));
    		System.out.println("\nGallery Text: " + row.get("gallery_text") + "\n");
    	}
    }

    	public void query02() {
    		// Query for a list of objects - automatic mapping from row to object using RowMapper class
    		// Using parameterised "prepared statements" reduces the risk of a SQL inject attack

    		System.out.println("\nQuery 2 (List of Objects from 1960 using RowMapper)\n-----------------");

    		String sql = "SELECT * FROM chObject WHERE date = ?";
    		List<ChObject> chObjects = jdbcTemplate.query(sql, new Object[] { "1960" }, new ChObjectRowMapper());

    		for (ChObject chObject : chObjects) {
    			System.out.println(chObject.toString());
    		}
    	}

    	public void query03() {
    		// Query for a specific object - automatic mapping from row to object using RowMapper class

    		System.out.println("\nQuery 3 (Print artist with id 68268707 - uses RowMapper)\n------------------");

    		String sql = "SELECT * FROM chObject WHERE id = ?";
    		ChObject chObject = jdbcTemplate.queryForObject(sql, new Object[] { 68268707 }, new ChObjectRowMapper());

    		System.out.println(chObject.toString());
    	}

    	@SuppressWarnings("deprecation")
		public void query04() {
    		// Query for specific column values

    		System.out.println("\nQuery 4 (Specfic columns)\n------------------");

    		// Old version (now deprecated)
    		String sql = "SELECT count(*) FROM chObject";
    		int chObjectCount = jdbcTemplate.queryForInt(sql);
    		System.out.printf("Number of Cultural Heritage Objects: %d\n", chObjectCount);

    		// New way
    		sql = "SELECT count(*) FROM participants";
    		int participantsCount = jdbcTemplate.queryForObject(sql, Integer.class);
    		System.out.printf("Number of movements: %d\n", participantsCount);

    		// Getting a map of values
    		sql = "SELECT id, title FROM chObject WHERE date = 1960";
    		Map<String, Object> map = jdbcTemplate.queryForMap(sql);
    		System.out.printf("ID: %s, Title: %s\n", map.get("id"),
    						map.get("title") +"\n");
    	}

    	/*public void query05() {
    		// Specific chObject and the chObject's participants (many-to-many)
    		// This is an inefficient version with 2 separate queries

    		System.out.println("\nQuery 5 (Print chObject and participants - 2 queries)\n------------------");

    		String sql = "SELECT * FROM chObject WHERE id = ?";
    		ChObject chObject = jdbcTemplate.queryForObject(sql, new Object[] { 68268701 }, new ChObjectRowMapper());

    		sql = "SELECT p.* FROM participants p, chObject_participants am WHERE p.id = am.participants_id AND am.chObject_id = ?";
    		List<Participants> participants = jdbcTemplate.query(sql, new Object[] { 68268701 }, new ParticipantsRowMapper());

    		chObject.setParticipants(participants);

    		System.out.println(chObject.toString());
    	}*/

    	/*public void repositoryExample() {
    		ChObject chObject = chObjectRepository.get(68268203);
    		System.out.println(chObject.toString());

    		ChObject newChObject = new ChObject();
    		newChObject.setId(123456789);
    		newChObject.setTitle("My ChObject");
    		newChObject.setDate(1960);
    		newChObject.setMedium("Canvas");
    		newChObject.setCreditline("Gift of me");
    		newChObject.setDescription("Short description about my object");
    		newChObject.setGallery_text("Why");
    		chObjectRepository.save(newChObject);

    		System.out.println("All ChObjects:");
    		List<ChObject> chObjects = chObjectRepository.findAll();
    		for (ChObject o : chObjects) {
    			System.out.println(o.toString());
    		}
    	}*/

    }


text:
NamespacedAssetsRails
=====

Tools to improve your life as Rails developer.

Javascript Organizer
--------------------

You can write your javascript functions using [yojs namespaces declaration](https://github.com/namespaced_assets_rails/yojs). Namespaces that matches your application name, current controller and current action will automatic be fired.

### Setup

- Put in your Gemfile:

```ruby
gem 'namespaced_assets_rails'
```

- Install the gem with *bundle install*

- Put in your layout:

`<%= load_yojs(:app_name => 'yourappname') %>`

- Put in your application.js

```javascript
//= require jquery
//= require yojs
```

- Declare your functions using yojs and enjoy your life

**Options**

***app_name***

The *load_yojs* helper method will print a javascript code, using query and yojs, that calls namespaces matching the app_name option, current controller name and current action name.

For instance, if you're in /posts/new it will call:

1. yourappname

2. yourappname.posts

3. yourappname.posts.new

***onload_method_name***

You can set the name of the last namespace to be called on the unload event with the *onload_method_name* option. For instance:

```erb
<%= load_yojs(:app_name => 'yourappname', :onload_method_name => "myonloadmethod") %>
```

If you're in /posts/new it will call:

1. yourappname.<myonloadmethod>

2. yourappname.posts.<myonloadmethod>

3. yourappname.posts.new.<myonloadmethod>

***method_names_mapper***

You can also configure equivalent namespaces using :<method_names_mapper. For instance:>

```erb
<%= load_yojs(:app_name => 'yourappname',

                     :method_names_mapper => {

                                  :create => :new,

                                  :update => :edit

                                }

                    )%>
```

If you're in /posts/create it will call:

1. yourappname

2. yourappname.posts

3. yourappname.posts.create

4. yourappname.posts.new

File structure
--------------------

We recomend you to structure your js files according your namespace hierarchy. Example

```
- assets
  |- javascripts
     |- application.js
     |- components (jquery, plugins, etc)
     |- myapp
     |  |- myapp.js (global javascripts in "myapp" namespace)
     |  |- controller1
     |  |  |- controller1.js (javascripts shared between "myapp.controller1" namespace)
     |  |  |- action1.js (javascripts for "myapp.controller1.action1" namespace)
     |  |  |- action2.js (javascripts for "myapp.controller1.action2" namespace)
     |  |  |- actionN.js (javascripts for "myapp.controller1.actionN" namespace)
     |  |
     |  |- controller2
     |  |  |- controller2.js (javascripts shared between "myapp.controller2" namespace)
     |  |  |- action1.js (javascripts for "myapp.controller2.action1" namespace)
     |  |  |- action2.js (javascripts for "myapp.controller2.action2" namespace)
     |  |  |- actionN.js (javascripts for "myapp.controller2.actionN" namespace)
     |  |
     |  |- controllerN
     |  |  |- controllerN.js (javascripts shared between "myapp.controllerN" namespace)
     |  |  |- ...
```


text:
The following example rotates a PNG image 90°.

```php
<?php

use GImage\Image;

$image = new Image();
$image
    ->load('https://i.imgur.com/G5MR088.png')
    // Rotate 90°
    ->rotate(90)
    // Save on local
    ->save('rotate_image.png');
```


text:
<?php
class TagsController extends AppController {
    var $name = 'Tags';
    var $helpers = array('Html','Javascript','Form','Ajax');
    var $uses = array('Tag','SearchIndex');
    //var $scaffold;

    function add() {
    	if (!empty($this->data)){
	       	if($this->Tag->save($this->data)){
                $this->Session->setFlash('Your Tags has been saved');
                $this->redirect(array('action'=> 'index'));
            }
	    }
    }

    function autoComplete() {
        //Partial strings will come from the autocomplete field as
        //$this->data['Tag']['Tag']
        Configure::write('debug', 0);
        $this->layout = 'ajax';

        //query to retrieve the autocomplete values
        $tagFields = array('tag');
        $tagConditions = array('Tag.tag LIKE' => $this->params['url']['q'].'%');
        $tagParams = array('conditions' => $tagConditions,'fields' => $tagFields);

        $this->set('tags', $this->Tag->find('all', $tagParams));

    }

    function sTag($tag = null) {
        //disable need for a view
        $tag = array();
        $tag['Tag']['tag'] = "gi22";
     	$this->autoRender=false;
        //$this->SearchIndex->create();
        //$this->Tag->Setup();
        $this->Tag->create();
        $this->Tag->save($tag, array('validate' => 'false'));

        return $this->Tag->id;
    }

}

?>


text:
namespace Microsoft.Azure.Management.DataFactory.Models
{

    /// <summary>
    /// Defines values for IntegrationRuntimeUpdateResult.
    /// </summary>
    public static class IntegrationRuntimeUpdateResult
    {
        public const string None = "None";
        public const string Succeed = "Succeed";
        public const string Fail = "Fail";
    }
}


text:
package com.tutorial.glb2d;

import android.app.Activity;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.widget.Toast;

import com.unit9.joseprodriguez.controllers.GameOnClickListener;
import com.unit9.joseprodriguez.renderer.Renderer;

public class MainActivity extends Activity {

	private static MainActivity instance;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		instance = this;
		GLSurfaceView view = new GLSurfaceView(this);
		Renderer renderer = new Renderer(this);
		view.setRenderer(renderer);

		// Register touch listener.
		view.setOnTouchListener(new GameOnClickListener(renderer));
		setContentView(view);
	}

	/**
	 * Game over :(
	 */
	public static void gameOver() {
		instance.runOnUiThread(new Runnable() {

			@Override
			public void run() {
				Toast.makeText(instance, "You lost a life!", Toast.LENGTH_LONG).show();
			}
		});
	}
}


text:
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context="com.plnyyanks.frcnotebook.activities.FieldMonitorActivity" >

    <item android:id="@+id/action_refresh_field_monitor"
          android:title="@string/action_refresh"
          android:orderInCategory="90"
          android:showAsAction="always|withText"
          android:icon="@drawable/ic_action_refresh"/>

    <item android:id="@+id/action_settings"
        android:title="@string/action_settings"
        android:orderInCategory="100"
        android:showAsAction="never" />
</menu>