#ifndef SASS_DEBUGGER_H
#define SASS_DEBUGGER_H

#include <string>
#include <sstream>
#include "node.hpp"
#include "ast_fwd_decl.hpp"

using namespace std;
using namespace Sass;

inline string str_replace(std::string str, const std::string& oldStr, const std::string& newStr)
{
  size_t pos = 0;
  while((pos = str.find(oldStr, pos)) != std::string::npos)
  {
     str.replace(pos, oldStr.length(), newStr);
     pos += newStr.length();
  }
  return str;
}

inline string prettyprint(const string& str) {
  string clean = str_replace(str, "\n", "\\n");
  clean = str_replace(clean, "	", "\\t");
  clean = str_replace(clean, "\r", "\\r");
  return clean;
}

inline string longToHex(long long t) {
  std::stringstream is;
  is << std::hex << t;
  return is.str();
}

inline string pstate_source_position(AST_Node* node)
{
  stringstream str;
  Position start(node->pstate());
  Position end(start + node->pstate().offset);
  str << (start.file == string::npos ? -1 : start.file)
    << "@[" << start.line << ":" << start.column << "]"
    << "-[" << end.line << ":" << end.column << "]";
  return str.str();
}

inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
{
  if (node == 0) return;
  if (ind == "") cerr << "####################################################################\n";
  if (dynamic_cast<Bubble*>(node)) {
    Bubble* bubble = dynamic_cast<Bubble*>(node);
    cerr << ind << "Bubble " << bubble;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << bubble->tabs();
    cerr << endl;
  } else if (dynamic_cast<At_Root_Block*>(node)) {
    At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
    cerr << ind << "At_Root_Block " << root_block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << root_block->tabs();
    cerr << endl;
    if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Selector_List*>(node)) {
    Selector_List* selector = dynamic_cast<Selector_List*>(node);
    cerr << ind << "Selector_List " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [@media:" << selector->media_block() << "]";
    cerr << (selector->is_optional() ? " [is_optional]": " -");
    cerr << (selector->has_line_break() ? " [line-break]": " -");
    cerr << (selector->has_line_feed() ? " [line-feed]": " -");
    cerr << endl;

    for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }

//  } else if (dynamic_cast<Expression*>(node)) {
//    Expression* expression = dynamic_cast<Expression*>(node);
//    cerr << ind << "Expression " << expression << " " << expression->concrete_type() << endl;

  } else if (dynamic_cast<Parent_Selector*>(node)) {
    Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
    cerr << ind << "Parent_Selector " << selector;
//    if (selector->not_selector()) cerr << " [in_declaration]";
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
//    debug_ast(selector->selector(), ind + "->", env);

  } else if (dynamic_cast<Complex_Selector*>(node)) {
    Complex_Selector* selector = dynamic_cast<Complex_Selector*>(node);
    cerr << ind << "Complex_Selector " << selector
      << " (" << pstate_source_position(node) << ")"
      << " [weight:" << longToHex(selector->specificity()) << "]"
      << " [@media:" << selector->media_block() << "]"
      << (selector->is_optional() ? " [is_optional]": " -")
      << (selector->has_line_feed() ? " [line-feed]": " -")
      << (selector->has_line_break() ? " [line-break]": " -")
      << " -- ";
      string del;
      switch (selector->combinator()) {
        case Complex_Selector::PARENT_OF:   del = ">"; break;
        case Complex_Selector::PRECEDES:    del = "~"; break;
        case Complex_Selector::ADJACENT_TO: del = "+"; break;
        case Complex_Selector::ANCESTOR_OF: del = " "; break;
        case Complex_Selector::REFERENCE:   del = "//"; break;
      }
      // if (del = "/") del += selector->reference()->perform(&to_string) + "/";
    cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
    debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
    if (selector->tail()) {
      debug_ast(selector->tail(), ind + "{" + del + "}", env);
    } else if(del != " ") {
      cerr << ind << " |" << del << "| {trailing op}" << endl;
    }
  } else if (dynamic_cast<Compound_Selector*>(node)) {
    Compound_Selector* selector = dynamic_cast<Compound_Selector*>(node);
    cerr << ind << "Compound_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [weight:" << longToHex(selector->specificity()) << "]";
    cerr << " [@media:" << selector->media_block() << "]";
    cerr << (selector->is_optional() ? " [is_optional]": " -");
    cerr << (selector->has_line_break() ? " [line-break]": " -");
    cerr << (selector->has_line_feed() ? " [line-feed]": " -");
    cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
    for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Propset*>(node)) {
    Propset* selector = dynamic_cast<Propset*>(node);
    cerr << ind << "Propset " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << selector->tabs() << endl;
    if (selector->block()) for(auto i : selector->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Wrapped_Selector*>(node)) {
    Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
    cerr << ind << "Wrapped_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << selector->ns_name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
    debug_ast(selector->selector(), ind + " () ", env);
  } else if (dynamic_cast<Pseudo_Selector*>(node)) {
    Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
    cerr << ind << "Pseudo_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << selector->ns_name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
    debug_ast(selector->expression(), ind + " <= ", env);
  } else if (dynamic_cast<Attribute_Selector*>(node)) {
    Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
    cerr << ind << "Attribute_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << selector->ns_name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
    debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
  } else if (dynamic_cast<Selector_Qualifier*>(node)) {
    Selector_Qualifier* selector = dynamic_cast<Selector_Qualifier*>(node);
    cerr << ind << "Selector_Qualifier " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << selector->ns_name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
  } else if (dynamic_cast<Type_Selector*>(node)) {
    Type_Selector* selector = dynamic_cast<Type_Selector*>(node);
    cerr << ind << "Type_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << selector->ns_name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") <<
      " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
  } else if (dynamic_cast<Selector_Placeholder*>(node)) {

    Selector_Placeholder* selector = dynamic_cast<Selector_Placeholder*>(node);
    cerr << ind << "Selector_Placeholder [" << selector->ns_name() << "] " << selector
      << " [@media:" << selector->media_block() << "]"
      << (selector->is_optional() ? " [is_optional]": " -")
      << (selector->has_line_break() ? " [line-break]": " -")
      << (selector->has_line_feed() ? " [line-feed]": " -")
    << endl;

  } else if (dynamic_cast<Simple_Selector*>(node)) {
    Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
    cerr << ind << "Simple_Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;

  } else if (dynamic_cast<Selector_Schema*>(node)) {
    Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
    cerr << ind << "Selector_Schema " << selector;
    cerr << " (" << pstate_source_position(node) << ")"
      << (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
      << " [@media:" << selector->media_block() << "]"
      << (selector->has_line_break() ? " [line-break]": " -")
      << (selector->has_line_feed() ? " [line-feed]": " -")
    << endl;

    debug_ast(selector->contents(), ind + " ");
    // for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }

  } else if (dynamic_cast<Selector*>(node)) {
    Selector* selector = dynamic_cast<Selector*>(node);
    cerr << ind << "Selector " << selector;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << (selector->has_line_break() ? " [line-break]": " -")
      << (selector->has_line_feed() ? " [line-feed]": " -")
    << endl;

  } else if (dynamic_cast<Media_Query_Expression*>(node)) {
    Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
    cerr << ind << "Media_Query_Expression " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
    << endl;
    debug_ast(block->feature(), ind + " feature) ");
    debug_ast(block->value(), ind + " value) ");

  } else if (dynamic_cast<Media_Query*>(node)) {
    Media_Query* block = dynamic_cast<Media_Query*>(node);
    cerr << ind << "Media_Query " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << (block->is_negated() ? " [is_negated]": " -")
      << (block->is_restricted() ? " [is_restricted]": " -")
    << endl;
    debug_ast(block->media_type(), ind + " ");
    for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }

  } else if (dynamic_cast<Media_Block*>(node)) {
    Media_Block* block = dynamic_cast<Media_Block*>(node);
    cerr << ind << "Media_Block " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->media_queries(), ind + " =@ ");
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Supports_Block*>(node)) {
    Supports_Block* block = dynamic_cast<Supports_Block*>(node);
    cerr << ind << "Supports_Block " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Block*>(node)) {
    Block* root_block = dynamic_cast<Block*>(node);
    cerr << ind << "Block " << root_block;
    cerr << " (" << pstate_source_position(node) << ")";
    if (root_block->is_root()) cerr << " [root]";
    cerr << " " << root_block->tabs() << endl;
    if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Warning*>(node)) {
    Warning* block = dynamic_cast<Warning*>(node);
    cerr << ind << "Warning " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Error*>(node)) {
    Error* block = dynamic_cast<Error*>(node);
    cerr << ind << "Error " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Debug*>(node)) {
    Debug* block = dynamic_cast<Debug*>(node);
    cerr << ind << "Debug " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Comment*>(node)) {
    Comment* block = dynamic_cast<Comment*>(node);
    cerr << ind << "Comment " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() <<
      " <" << prettyprint(block->pstate().token.ws_before()) << ">" << endl;
    debug_ast(block->text(), ind + "// ", env);
  } else if (dynamic_cast<If*>(node)) {
    If* block = dynamic_cast<If*>(node);
    cerr << ind << "If " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->predicate(), ind + " = ");
    debug_ast(block->block(), ind + " <>");
    debug_ast(block->alternative(), ind + " ><");
  } else if (dynamic_cast<Return*>(node)) {
    Return* block = dynamic_cast<Return*>(node);
    cerr << ind << "Return " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Extension*>(node)) {
    Extension* block = dynamic_cast<Extension*>(node);
    cerr << ind << "Extension " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->selector(), ind + "-> ", env);
  } else if (dynamic_cast<Content*>(node)) {
    Content* block = dynamic_cast<Content*>(node);
    cerr << ind << "Content " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Import_Stub*>(node)) {
    Import_Stub* block = dynamic_cast<Import_Stub*>(node);
    cerr << ind << "Import_Stub " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
  } else if (dynamic_cast<Import*>(node)) {
    Import* block = dynamic_cast<Import*>(node);
    cerr << ind << "Import " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->media_queries(), ind + " @ ");
    // vector<string>         files_;
    for (auto imp : block->urls()) debug_ast(imp, "@ ", env);
  } else if (dynamic_cast<Assignment*>(node)) {
    Assignment* block = dynamic_cast<Assignment*>(node);
    cerr << ind << "Assignment " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " <<" << block->variable() << ">> " << block->tabs() << endl;
    debug_ast(block->value(), ind + "=", env);
  } else if (dynamic_cast<Declaration*>(node)) {
    Declaration* block = dynamic_cast<Declaration*>(node);
    cerr << ind << "Declaration " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->property(), ind + " prop: ", env);
    debug_ast(block->value(), ind + " value: ", env);
  } else if (dynamic_cast<Keyframe_Rule*>(node)) {
    Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
    cerr << ind << "Keyframe_Rule " << has_block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << has_block->tabs() << endl;
    if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
    if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<At_Rule*>(node)) {
    At_Rule* block = dynamic_cast<At_Rule*>(node);
    cerr << ind << "At_Rule " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << block->keyword() << "] " << block->tabs() << endl;
    debug_ast(block->selector(), ind + "~", env);
    debug_ast(block->value(), ind + "+", env);
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Each*>(node)) {
    Each* block = dynamic_cast<Each*>(node);
    cerr << ind << "Each " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<For*>(node)) {
    For* block = dynamic_cast<For*>(node);
    cerr << ind << "For " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<While*>(node)) {
    While* block = dynamic_cast<While*>(node);
    cerr << ind << "While " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << block->tabs() << endl;
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Definition*>(node)) {
    Definition* block = dynamic_cast<Definition*>(node);
    cerr << ind << "Definition " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [name: " << block->name() << "] ";
    cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
    // this seems to lead to segfaults some times?
    // cerr << " [signature: " << block->signature() << "] ";
    cerr << " [native: " << block->native_function() << "] ";
    cerr << " " << block->tabs() << endl;
    debug_ast(block->parameters(), ind + " params: ", env);
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Mixin_Call*>(node)) {
    Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
    cerr << ind << "Mixin_Call " << block << " " << block->tabs();
    cerr << " [" <<  block->name() << "]" << endl;
    debug_ast(block->arguments(), ind + " args: ");
    if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
    cerr << ind << "Ruleset " << ruleset;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [indent: " << ruleset->tabs() << "]";
    cerr << (ruleset->at_root() ? " [@ROOT]" : "");
    cerr << endl;
    debug_ast(ruleset->selector(), ind + ">");
    debug_ast(ruleset->block(), ind + " ");
  } else if (dynamic_cast<Block*>(node)) {
    Block* block = dynamic_cast<Block*>(node);
    cerr << ind << "Block " << block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [indent: " << block->tabs() << "]" << endl;
    for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Textual*>(node)) {
    Textual* expression = dynamic_cast<Textual*>(node);
    cerr << ind << "Textual ";
    if (expression->type() == Textual::NUMBER) cerr << " [NUMBER]";
    else if (expression->type() == Textual::PERCENTAGE) cerr << " [PERCENTAGE]";
    else if (expression->type() == Textual::DIMENSION) cerr << " [DIMENSION]";
    else if (expression->type() == Textual::HEX) cerr << " [HEX]";
    cerr << expression << " [" << expression->value() << "]";
    if (expression->is_delayed()) cerr << " [delayed]";
    cerr << endl;
  } else if (dynamic_cast<Variable*>(node)) {
    Variable* expression = dynamic_cast<Variable*>(node);
    cerr << ind << "Variable " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->name() << "]" << endl;
    string name(expression->name());
    if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
  } else if (dynamic_cast<Function_Call_Schema*>(node)) {
    Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
    cerr << ind << "Function_Call_Schema " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << "" << endl;
    debug_ast(expression->name(), ind + "name: ", env);
    debug_ast(expression->arguments(), ind + " args: ", env);
  } else if (dynamic_cast<Function_Call*>(node)) {
    Function_Call* expression = dynamic_cast<Function_Call*>(node);
    cerr << ind << "Function_Call " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->name() << "]" << endl;
    debug_ast(expression->arguments(), ind + " args: ", env);
  } else if (dynamic_cast<Arguments*>(node)) {
    Arguments* expression = dynamic_cast<Arguments*>(node);
    cerr << ind << "Arguments " << expression;
    if (expression->is_delayed()) cerr << " [delayed]";
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << endl;
    for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Argument*>(node)) {
    Argument* expression = dynamic_cast<Argument*>(node);
    cerr << ind << "Argument " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->value() << "]";
    cerr << " [name: " << expression->name() << "] ";
    cerr << " [rest: " << expression->is_rest_argument() << "] ";
    cerr << " [keyword: " << expression->is_keyword_argument() << "] " << endl;
    debug_ast(expression->value(), ind + " value: ", env);
  } else if (dynamic_cast<Parameters*>(node)) {
    Parameters* expression = dynamic_cast<Parameters*>(node);
    cerr << ind << "Parameters " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
    cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
    cerr << endl;
    for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Parameter*>(node)) {
    Parameter* expression = dynamic_cast<Parameter*>(node);
    cerr << ind << "Parameter " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [name: " << expression->name() << "] ";
    cerr << " [default: " << expression->default_value() << "] ";
    cerr << " [rest: " << expression->is_rest_parameter() << "] " << endl;
  } else if (dynamic_cast<Unary_Expression*>(node)) {
    Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
    cerr << ind << "Unary_Expression " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->type() << "]" << endl;
    debug_ast(expression->operand(), ind + " operand: ", env);
  } else if (dynamic_cast<Binary_Expression*>(node)) {
    Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
    cerr << ind << "Binary_Expression " << expression;
    cerr << " [delayed: " << expression->is_delayed() << "] ";
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->type_name() << "]" << endl;
    debug_ast(expression->left(), ind + " left:  ", env);
    debug_ast(expression->right(), ind + " right: ", env);
  } else if (dynamic_cast<Map*>(node)) {
    Map* expression = dynamic_cast<Map*>(node);
    cerr << ind << "Map " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [Hashed]" << endl;
    for (auto i : expression->elements()) {
      debug_ast(i.first, ind + " key: ");
      debug_ast(i.second, ind + " val: ");
    }
  } else if (dynamic_cast<List*>(node)) {
    List* expression = dynamic_cast<List*>(node);
    cerr << ind << "List " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " (" << expression->length() << ") " <<
      (expression->separator() == SASS_COMMA ? "Comma " : "Space ") <<
      " [delayed: " << expression->is_delayed() << "] " <<
      " [interpolant: " << expression->is_interpolant() << "] " <<
      " [arglist: " << expression->is_arglist() << "] " <<
      " [hash: " << expression->hash() << "] " <<
      endl;
    for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Content*>(node)) {
    Content* expression = dynamic_cast<Content*>(node);
    cerr << ind << "Content " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [Statement]" << endl;
  } else if (dynamic_cast<Boolean*>(node)) {
    Boolean* expression = dynamic_cast<Boolean*>(node);
    cerr << ind << "Boolean " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->value() << "]" << endl;
  } else if (dynamic_cast<Color*>(node)) {
    Color* expression = dynamic_cast<Color*>(node);
    cerr << ind << "Color " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->r() << ":"  << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << endl;
  } else if (dynamic_cast<Number*>(node)) {
    Number* expression = dynamic_cast<Number*>(node);
    cerr << ind << "Number " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << expression->value() << expression->unit() << "]" << endl;
  } else if (dynamic_cast<String_Quoted*>(node)) {
    String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
    cerr << ind << "String_Quoted " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << prettyprint(expression->value()) << "]";
    if (expression->is_delayed()) cerr << " [delayed]";
    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
    if (expression->quote_mark()) cerr << " [quote_mark: " << expression->quote_mark() << "]";
    cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
  } else if (dynamic_cast<String_Constant*>(node)) {
    String_Constant* expression = dynamic_cast<String_Constant*>(node);
    cerr << ind << "String_Constant " << expression;
    if (expression->concrete_type()) {
      cerr << " " << expression->concrete_type();
    }
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " [" << prettyprint(expression->value()) << "]";
    if (expression->is_delayed()) cerr << " [delayed]";
    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
    cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
  } else if (dynamic_cast<String_Schema*>(node)) {
    String_Schema* expression = dynamic_cast<String_Schema*>(node);
    cerr << ind << "String_Schema " << expression;
    cerr << " " << expression->concrete_type();
    if (expression->is_delayed()) cerr << " [delayed]";
    if (expression->has_interpolants()) cerr << " [has_interpolants]";
    cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
    for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<String*>(node)) {
    String* expression = dynamic_cast<String*>(node);
    cerr << ind << "String " << expression;
    cerr << " " << expression->concrete_type();
    cerr << " (" << pstate_source_position(node) << ")";
    if (expression->sass_fix_1291()) cerr << " [sass_fix_1291]";
    cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
  } else if (dynamic_cast<Expression*>(node)) {
    Expression* expression = dynamic_cast<Expression*>(node);
    cerr << ind << "Expression " << expression;
    cerr << " (" << pstate_source_position(node) << ")";
    switch (expression->concrete_type()) {
      case Expression::Concrete_Type::NONE: cerr << " [NONE]"; break;
      case Expression::Concrete_Type::BOOLEAN: cerr << " [BOOLEAN]"; break;
      case Expression::Concrete_Type::NUMBER: cerr << " [NUMBER]"; break;
      case Expression::Concrete_Type::COLOR: cerr << " [COLOR]"; break;
      case Expression::Concrete_Type::STRING: cerr << " [STRING]"; break;
      case Expression::Concrete_Type::LIST: cerr << " [LIST]"; break;
      case Expression::Concrete_Type::MAP: cerr << " [MAP]"; break;
      case Expression::Concrete_Type::SELECTOR: cerr << " [SELECTOR]"; break;
      case Expression::Concrete_Type::NULL_VAL: cerr << " [NULL_VAL]"; break;
      case Expression::Concrete_Type::C_WARNING: cerr << " [C_WARNING]"; break;
      case Expression::Concrete_Type::C_ERROR: cerr << " [C_ERROR]"; break;
      case Expression::Concrete_Type::NUM_TYPES: cerr << " [NUM_TYPES]"; break;
    }
    cerr << endl;
  } else if (dynamic_cast<Has_Block*>(node)) {
    Has_Block* has_block = dynamic_cast<Has_Block*>(node);
    cerr << ind << "Has_Block " << has_block;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << has_block->tabs() << endl;
    if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
  } else if (dynamic_cast<Statement*>(node)) {
    Statement* statement = dynamic_cast<Statement*>(node);
    cerr << ind << "Statement " << statement;
    cerr << " (" << pstate_source_position(node) << ")";
    cerr << " " << statement->tabs() << endl;
  }

  if (ind == "") cerr << "####################################################################\n";
}

inline void debug_node(Node* node, string ind = "")
{
  if (ind == "") cerr << "#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
  if (node->isCombinator()) {
    cerr << ind;
    cerr << "Combinator ";
    cerr << node << " ";
    if (node->got_line_feed) cerr << "[LF] ";
    switch (node->combinator()) {
      case Complex_Selector::ADJACENT_TO: cerr << "{+} "; break;
      case Complex_Selector::PARENT_OF:   cerr << "{>} "; break;
      case Complex_Selector::PRECEDES:    cerr << "{~} "; break;
      case Complex_Selector::REFERENCE:   cerr << "{@} "; break;
      case Complex_Selector::ANCESTOR_OF: cerr << "{ } "; break;
    }
    cerr << endl;
    // debug_ast(node->combinator(), ind + "  ");
  } else if (node->isSelector()) {
    cerr << ind;
    cerr << "Selector ";
    cerr << node << " ";
    if (node->got_line_feed) cerr << "[LF] ";
    cerr << endl;
    debug_ast(node->selector(), ind + "  ");
  } else if (node->isCollection()) {
    cerr << ind;
    cerr << "Collection ";
    cerr << node << " ";
    if (node->got_line_feed) cerr << "[LF] ";
    cerr << endl;
    for(auto n : (*node->collection())) {
      debug_node(&n, ind + "  ");
    }
  } else if (node->isNil()) {
    cerr << ind;
    cerr << "Nil ";
    cerr << node << " ";
    if (node->got_line_feed) cerr << "[LF] ";
    cerr << endl;
  } else {
    cerr << ind;
    cerr << "OTHER ";
    cerr << node << " ";
    if (node->got_line_feed) cerr << "[LF] ";
    cerr << endl;
  }
  if (ind == "") cerr << "#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
}

inline void debug_ast(const AST_Node* node, string ind = "", Env* env = 0)
{
  debug_ast(const_cast<AST_Node*>(node), ind, env);
}

inline void debug_node(const Node* node, string ind = "")
{
  debug_node(const_cast<Node*>(node), ind);
}

inline void debug_extenstion_map(Sass::ExtensionSubsetMap* map, string ind = "")
{
  if (ind == "") cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
  for(auto const &it : map->values()) {
    debug_ast(it.first, ind + "first: ");
    debug_ast(it.second, ind + "second: ");
  }
  if (ind == "") cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
}

typedef pair<Complex_Selector*, Compound_Selector*> ExtensionPair;
typedef vector<ExtensionPair> SubsetMapEntries;

inline void debug_subset_entries(SubsetMapEntries* entries, string ind = "")
{
  if (ind == "") cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
  for(auto const &pair : *entries) {
    debug_ast(pair.first, ind + "first: ");
    debug_ast(pair.second, ind + "second: ");
  }
  if (ind == "") cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
}

#endif // SASS_DEBUGGER


The Best è un album compilation di brani dal 1986 al 1990 della Steve Rogers Band, pubblicato il 27 agosto 1993.

Descrizione
Nel 1991 il gruppo decise, dopo aver svolto il tour di promozione dell'album Sono donne, di sciogliersi definitivamente. I primi a dare l'addio furono il chitarrista Maurizio Solieri e il bassista Claudio Golinelli, che tornarono da Vasco Rossi che viveva un periodo di grande successo, con il tour negli stadi ("Flaminio" di Roma e "San Siro" di Milano) dell'estate passata, con sold-out e affluenza di pubblico superiore a quella riscontrata da Madonna e Rolling Stones. Seguirà qualche mese dopo il front-man Massimo Riva, che si lanciò nella carriera solista che sfociò nel 1992 nell'album Matti come tutti. Fu così che la CBS, etichetta della band, propose ai fan una raccolta di brani proposti nell'arco di 4 anni dalla rock-band italiana. Il disco comprendeva fra l'altro la One-hit wonder Alzati la gonna, il brano del Festival di Sanremo 1989 Uno di noi e il singolo dell'estate 1990 Hey Man (la tua donna mi fa impazzire).

Tracce
 Alzati la gonna (dall'omonimo album, 1988)
 Tanto è lo stesso (Steve Rogers Band, 1989)
 Uno in più (Steve Rogers Band, 1989)
 Me ne vado (I duri non ballano, 1986)
 Uno di noi (Steve Rogers Band, 1989)
 Ok sì (I duri non ballano, 1986)
 Hey Man (la tua donna mi fa impazzire) (Sono donne, 1990)
 Bambolina (Alzati la gonna, 1988)
 Questa sera rock'n'roll (I duri non ballano, 1986)
 Sono donne (dall'omonimo album, 1990)
 Caro amico (Alzati la gonna, 1988)
 C'è chi nasce donna (I duri non ballano, 1986)

Musicisti
 Massimo Riva: voce, chitarra ritmica
 Maurizio Solieri: chitarra solista
 Claudio Golinelli: basso
 Andrea Innesto: sax
 Mimmo Camporeale: tastiere
 Beppe Leoncini: batteria
 Daniele Tedeschi: batteria (nell'album I duri non ballano)

Altri musicisti
 Stefano Bittelli: computer system
 Guido Elmi: percussioni, programmazione, effetti speciali
 Giacomo Giannotti: tastiera, arrangiamento Fiati
 Lele Melotti: batteria in Uno in più
 Marco Sabiu: synclavier, tastiera
 Stefano Fariselli: sax
 Rudy Trevisi: sax
 Clara Moroni: cori
 Antonella Pepe: cori
 Silvio Pozzoli: cori

Produzione: Guido Elmi, Maurizio Biancani

Voci correlate
 Steve Rogers Band
 Vasco Rossi
 Massimo Riva
 I duri non ballano (album)
 Alzati la gonna
 Steve Rogers Band (album)
 Sono donne

{'title': 'The Best (Steve Rogers Band)', 'url': 'https://it.wikipedia.org/wiki/The%20Best%20%28Steve%20Rogers%20Band%29', 'language': 'it', 'timestamp': '20230320'}


Психоза је психички поремећај код кога је као примарни симптом присутно отуђење пацијента од реалности. Огледају се у поремећеном контакту или чак прекиду контакта са стварношћу, дубоким поремећајима опажања, емоција, мишљења и понашања. Психотичној особи често недостаје увид у сопствену болест, па стога болесник верује да није он битно поремећен, већ његова околина. Пошто се јављају поремећаји у понашању и мишљењу, лаици често мешају психозе, које називају лудилима, са урођеном слабоумношћу, тј. ниским интелектуалним способностима или су уверени да психотична особа говори само бесмислице. Међутим, неке психозе није лако одмах препознати, поготово у почетним фазама, нити оне морају да захвате целокупно понашање и све области психичког живота. Остају острва нормалних реакција у којима се ништа неуобичајено не примећује, или бар нема ничег упадљивог. Други симптоми могу да укључују неповезан говор и понашање које је неприкладно за ситуацију. Такође могу да се јаве поремећаји сна, социјално повлачење, недостатак мотивације и тешкоће у обављању свакодневних активности.

Психозе имају мноштво различитих узрока. Они обухватају душевне болести, као што су шизофренија или биполарни поремећај, депривација сна, поједина медицинска стања, поједини лекови, и дроге као што је алкохол или канабис. Један тип, познат као постпорођајна психоза, може се јавити након порођаја. Сматра се да неуротрансмитер допамин учествује у том процесу. Акутна психоза се сматра примарном ако је резултат психијатријског стања и секундарном ако је узрокована медицинским стањем. Дијагноза менталног обољења обухвата искључивање других потенцијалних узрока. Тестови се морају спровести да би се проверило за могуће постојање болести централног нервног система, присуство токсина, или других здравствених проблема као могућих узрочника.

Третман може да обухвата антипсихотичке лекове, саветовање, и друштвену подршку. Постоје индикације да рани третман побољшава исходе. Лекови имају умерени учинак. Исходи су зависни од суштинског узрочника. У Сједињеним Државама око 3% људи развије психозу у неком тренутку свог живота. Ово стање је било познато бар од 4. века п. н. е. према Хипократу са Коса а вероватно и још од 1.500 п. н. е. судећи по египатским записима на Еберским папирусима.

Знаци и симптоми

Халуцинације
Халуцинација се дефинише као сензорна перцепција у одсуству спољашњег стимулуса. Халуцинације нису исто што и илузије, или перцептуалне дисторзије које су погрешне перцепције спољашњих подражаја. Халуцинације се могу појавити у било ком чулу и попримити скоро сваки облик, што може укључивати једноставне сензације (као што су светла, боје, укуси и мириси) до искустава као што су виђење и интеракција са потпуно формираним животињама и људима, слушање гласова са комплексним тактилним сензацијама. Халуцинације су генерално карактерисане као вивидне и неконтролисане.

Звучне халуцинације, а посебно искуства при којима се чују гласови су најчешће, и обично су проминентно својство психозе. До 15% опште популације може да доживи звучне халуцинације. Преваленција код оболелих од схизофреније је генерално око 70%, мада може да буде и до 98%. Током раног 20. века слушне халуцинације су биле на другом месту по учесталости, иза визуелних халуцинација. Оне су у данашње време најчешћа манифестација схизофреније, мада ступњеви могу да варирају међу културама и регијама. Звучне халуцинације су најчешће разумљиви гласови. Када су присутни гласови, просечан број је процењен на три. Садржај, као и учесталост, значајно се разликују, посебно у различитим културама и демографији. Људи који доживљавају звучне халуцинације могу често да идентификују гласност и локацију порекла, и могу да одреде идентитете гласова. За западне културе су типични звучни доживљаји повезани са религијским садржајем, често у контексту греха. Халуцинације могу наредити особи да учини нешто што може бити опасно кад се уради у комбинацији са заблудама.

Екстракампинске халуцинације су слушне халуцинације које потичу из одређеног дела тела (нпр. глас који долази из колена особе).

Визуелне халуцинације се јављају код око трећине људи са шизофренијом, мада према неким подацима стопа може да буде 55%. Садржај често укључује анимиране објекте, мада се могу видети и перцептивне абнормалности као што су промене у осветљењу, осенчењу, пругама или линијама. Визуелне абнормалности могу да буду у конфликту са проприоцептивним информацијама, и визије могу да обухватају искуства као што је нагибање тла. Лилипутијске халуцинације су ређе код шизофреније, и чешће се јављају код разних типова енцефалопатије (нпр. педункуларна халуциноза).

Висцерална халуцинација, која се назива и ценестетичком халуцинацијом, је карактерисана висцералном сензацијом у одсуству стимуланса. Ценестетске халуцинације могу да обухватају осећај горења, или реорганизације унутрашњих органа.

Врсте психоза
Психозе се најчешће деле у две групе - пропратне, односно органске и ендогене, односно функционалне.

Пропратне психозе настају као израз неког органског обољења или поремећаја, на пример код трбушног тифуса, прогресивне парализе изазване сифилисом, маларије, поремећаја неких жлезда, алкохолизма итд. Како су ове психозе секундарног карактера, оне нестају ако се уклони основна болест или поремећај, под условом да је основно обољење излечиво. Те психозе се зато и називају органске, јер имају органску основу.

Другу групу чине функционалне психозе. Сматра се да у њиховом настајању важнију улогу имају урођени и наследни фактори, али исто тако и целокупан систем социјализације и чиниоци средине.

Једна од функционалних психоза је шизофренија. Ова реч је кованица и значи „расцеп душе“, слободније речено, распадање личности. Нажалост, по свему судећи, у питању је не једно, већ више обољења, са неким сличним и заједничким поремећајима. За ову психозу је карактеристично повлачење болесника у себе, ремећење и прекид контакта са стварношћу, губљење животног полета, поремећај емоција и мишљења (мишљење постаје збркано и нејасно) и постепено опадање способности мишљења (деменција), све до поремећаја нагона, када болесник одбија храну или узима и предмете који нису за исхрану. Мења се и говор болесника, може доћи до сажимања и спајања речи, па за околину тај говор постаје неразумљив. Може доћи до халуцинација, као и до суманутих идеја, када је на пример, болесник убеђен да га прогоне и трују. Може да га спопадне и огроман страх, па се дешава да изврши самоубиство или убиство.

Друга функционална психоза је манично-депресивна у којој су најизразитији поремећаји у емоционалном понашању. Ако се јавља претерана веселост, без разлога, бујица речи и идеја уз прецењене идеје болесника о сопственој вредности, говоримо о манији или манијакалном стању (ово најчешће нема везе са речју манијак коју користе лаици). Када се јављају јако жалосна расположења, меланхолична, потпуна безвољност, кочење мишића, осећај кривице - ради се о депресији или меланхоличном стању. Таква особа често не сматра да је болесна, већ верује да је стварно крива. Болесник окривљује себе за нешто због чега није крив, или што само по себи не би требало да изазове такво понашање. У таквом стању болесник може да изврши и самоубиство.

Има болесника код којих се периодично јављају само манична или само депресивна стања. Међутим, понекад се та два стања смењују - болесник је извесно време претерано радостан, а касније ненормално тужан, па се зато говори о манично-депресивној или циркуларној психози.
Ова болест, после завршетка једне или друге фазе, обично не узрокује велика оштећења. Лакше се смирује и зато није толики социјално-медицински проблем као шизофренија.

Референце

Литература

  [Semi-autobiographical]

Спољашње везе

 -{National Institute of Mental Health}-

Психоза
Психичка обољења
Психијатријске дијагнозе
Психопатологија
Психијатрија

{'title': 'Психоза', 'url': 'https://sr.wikipedia.org/wiki/%D0%9F%D1%81%D0%B8%D1%85%D0%BE%D0%B7%D0%B0', 'language': 'sr', 'timestamp': '20230320'}


package org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner;

import org.kie.workbench.common.stunner.bpmn.backend.converters.TypedFactoryManager;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.activities.BaseCallActivityConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.events.EndEventConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.events.IntermediateCatchEventConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.events.IntermediateThrowEventConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.events.StartEventConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.gateways.GatewayConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.lanes.LaneConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.processes.BaseRootProcessConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.processes.BaseSubProcessConverter;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.properties.PropertyReaderFactory;
import org.kie.workbench.common.stunner.bpmn.backend.converters.tostunner.tasks.BaseTaskConverter;

public abstract class BaseConverterFactory {

    protected final DefinitionResolver definitionResolver;
    protected final TypedFactoryManager factoryManager;
    protected final PropertyReaderFactory propertyReaderFactory;

    private final EdgeConverter edgeConverter;

    private final FlowElementConverter flowElementConverter;
    private final StartEventConverter startEventConverter;
    private final IntermediateCatchEventConverter intermediateCatchEventConverter;
    private final IntermediateThrowEventConverter intermediateThrowEventConverter;
    private final EndEventConverter endEventConverter;
    private final LaneConverter laneConverter;
    private final GatewayConverter gatewayConverter;

    public BaseConverterFactory(DefinitionResolver definitionResolver,
                                TypedFactoryManager factoryManager,
                                PropertyReaderFactory propertyReaderFactory) {
        this.definitionResolver = definitionResolver;
        this.factoryManager = factoryManager;
        this.propertyReaderFactory = propertyReaderFactory;

        this.flowElementConverter = new FlowElementConverter(this);

        this.startEventConverter = new StartEventConverter(factoryManager, propertyReaderFactory);
        this.intermediateCatchEventConverter = new IntermediateCatchEventConverter(factoryManager, propertyReaderFactory);
        this.intermediateThrowEventConverter = new IntermediateThrowEventConverter(factoryManager, propertyReaderFactory);
        this.endEventConverter = new EndEventConverter(factoryManager, propertyReaderFactory);
        this.laneConverter = new LaneConverter(factoryManager, propertyReaderFactory);
        this.gatewayConverter = new GatewayConverter(factoryManager, propertyReaderFactory);
        this.edgeConverter = new EdgeConverter(factoryManager, propertyReaderFactory);
    }

    public FlowElementConverter flowElementConverter() {
        return flowElementConverter;
    }

    public EdgeConverter edgeConverter() {
        return edgeConverter;
    }

    public StartEventConverter startEventConverter() {
        return startEventConverter;
    }

    public IntermediateCatchEventConverter intermediateCatchEventConverter() {
        return intermediateCatchEventConverter;
    }

    public IntermediateThrowEventConverter intermediateThrowEventConverter() {
        return intermediateThrowEventConverter;
    }

    public EndEventConverter endEventConverter() {
        return endEventConverter;
    }

    public abstract BaseCallActivityConverter callActivityConverter();

    public abstract BaseRootProcessConverter rootProcessConverter();

    public abstract BaseSubProcessConverter subProcessConverter();

    public LaneConverter laneConverter() {
        return laneConverter;
    }

    public GatewayConverter gatewayConverter() {
        return gatewayConverter;
    }

    public abstract BaseTaskConverter taskConverter();
}

{'content_hash': 'd09930620154377de87668b9c8ed56d9', 'timestamp': '', 'source': 'github', 'line_count': 90, 'max_line_length': 122, 'avg_line_length': 47.577777777777776, 'alnum_prop': 0.8038299859878562, 'repo_name': 'jhrcek/kie-wb-common', 'id': '9f237b2a9b5aea95cc4809ff4a3c781672c53105', 'size': '4901', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'kie-wb-common-stunner/kie-wb-common-stunner-sets/kie-wb-common-stunner-bpmn/kie-wb-common-stunner-bpmn-backend/src/main/java/org/kie/workbench/common/stunner/bpmn/backend/converters/tostunner/BaseConverterFactory.java', 'mode': '33188', 'license': 'apache-2.0', 'language': [{'name': 'Batchfile', 'bytes': '2591'}, {'name': 'CSS', 'bytes': '115195'}, {'name': 'Dockerfile', 'bytes': '210'}, {'name': 'FreeMarker', 'bytes': '36496'}, {'name': 'GAP', 'bytes': '86275'}, {'name': 'HTML', 'bytes': '331778'}, {'name': 'Java', 'bytes': '38263821'}, {'name': 'JavaScript', 'bytes': '20277'}, {'name': 'Shell', 'bytes': '905'}, {'name': 'Visual Basic', 'bytes': '84832'}]}


/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#ifndef NATIVE_EXTENSION_VTK_VTKTEMPORALARRAYOPERATORFILTERWRAP_H
#define NATIVE_EXTENSION_VTK_VTKTEMPORALARRAYOPERATORFILTERWRAP_H

#include <nan.h>

#include <vtkSmartPointer.h>
#include <vtkTemporalArrayOperatorFilter.h>

#include "vtkMultiTimeStepAlgorithmWrap.h"
#include "../../plus/plus.h"

class VtkTemporalArrayOperatorFilterWrap : public VtkMultiTimeStepAlgorithmWrap
{
	public:
		using Nan::ObjectWrap::Wrap;
		static void Init(v8::Local<v8::Object> exports);
		static void InitPtpl();
		static void ConstructorGetter(
			v8::Local<v8::String> property,
			const Nan::PropertyCallbackInfo<v8::Value>& info);

		VtkTemporalArrayOperatorFilterWrap(vtkSmartPointer<vtkTemporalArrayOperatorFilter>);
		VtkTemporalArrayOperatorFilterWrap();
		~VtkTemporalArrayOperatorFilterWrap( );
		static Nan::Persistent<v8::FunctionTemplate> ptpl;

	private:
		static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);

		static void GetFirstTimeStepIndex(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void GetOperator(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void GetOutputArrayNameSuffix(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void GetSecondTimeStepIndex(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void SetFirstTimeStepIndex(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void SetOperator(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void SetOutputArrayNameSuffix(const Nan::FunctionCallbackInfo<v8::Value>& info);
		static void SetSecondTimeStepIndex(const Nan::FunctionCallbackInfo<v8::Value>& info);

#ifdef VTK_NODE_PLUS_VTKTEMPORALARRAYOPERATORFILTERWRAP_CLASSDEF
		VTK_NODE_PLUS_VTKTEMPORALARRAYOPERATORFILTERWRAP_CLASSDEF
#endif
};

#endif

{'content_hash': 'a13fddc8f86aa09b533327c9cd35e7f3', 'timestamp': '', 'source': 'github', 'line_count': 49, 'max_line_length': 89, 'avg_line_length': 40.83673469387755, 'alnum_prop': 0.7971014492753623, 'repo_name': 'axkibe/node-vtk', 'id': '85362e9581f88e56b0309b5088c7f05c14122755', 'size': '2001', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'wrappers/8.1.1/vtkTemporalArrayOperatorFilterWrap.h', 'mode': '33188', 'license': 'bsd-3-clause', 'language': [{'name': 'C++', 'bytes': '75388342'}, {'name': 'CMake', 'bytes': '915'}, {'name': 'JavaScript', 'bytes': '70'}, {'name': 'Roff', 'bytes': '145455'}]}


from hashlib import md5, sha1

import cherrypy
from cherrypy._cpcompat import ntob
from cherrypy.lib import httpauth

from cherrypy.test import helper

class HTTPAuthTest(helper.CPWebCase):

    def setup_server():
        class Root:

            def index(self):
                return "This is public."
            index.exposed = True

        class DigestProtected:

            def index(self):
                return "Hello %s, you've been authorized." % (
                    cherrypy.request.login)
            index.exposed = True

        class BasicProtected:

            def index(self):
                return "Hello %s, you've been authorized." % (
                    cherrypy.request.login)
            index.exposed = True

        class BasicProtected2:

            def index(self):
                return "Hello %s, you've been authorized." % (
                    cherrypy.request.login)
            index.exposed = True

        def fetch_users():
            return {'test': 'test'}

        def sha_password_encrypter(password):
            return sha1(ntob(password)).hexdigest()

        def fetch_password(username):
            return sha1(ntob('test')).hexdigest()

        conf = {
            '/digest': {
                'tools.digest_auth.on': True,
                'tools.digest_auth.realm': 'localhost',
                'tools.digest_auth.users': fetch_users
            },
            '/basic': {
                'tools.basic_auth.on': True,
                'tools.basic_auth.realm': 'localhost',
                'tools.basic_auth.users': {
                    'test': md5(ntob('test')).hexdigest()
                }
            },
            '/basic2': {
                'tools.basic_auth.on': True,
                'tools.basic_auth.realm': 'localhost',
                'tools.basic_auth.users': fetch_password,
                'tools.basic_auth.encrypt': sha_password_encrypter
            }
        }

        root = Root()
        root.digest = DigestProtected()
        root.basic = BasicProtected()
        root.basic2 = BasicProtected2()
        cherrypy.tree.mount(root, config=conf)
    setup_server = staticmethod(setup_server)

    def testPublic(self):
        self.getPage("/")
        self.assertStatus('200 OK')
        self.assertHeader('Content-Type', 'text/html;charset=utf-8')
        self.assertBody('This is public.')

    def testBasic(self):
        self.getPage("/basic/")
        self.assertStatus(401)
        self.assertHeader('WWW-Authenticate', 'Basic realm="localhost"')

        self.getPage('/basic/', [('Authorization', 'Basic dGVzdDp0ZX60')])
        self.assertStatus(401)

        self.getPage('/basic/', [('Authorization', 'Basic dGVzdDp0ZXN0')])
        self.assertStatus('200 OK')
        self.assertBody("Hello test, you've been authorized.")

    def testBasic2(self):
        self.getPage("/basic2/")
        self.assertStatus(401)
        self.assertHeader('WWW-Authenticate', 'Basic realm="localhost"')

        self.getPage('/basic2/', [('Authorization', 'Basic dGVzdDp0ZX60')])
        self.assertStatus(401)

        self.getPage('/basic2/', [('Authorization', 'Basic dGVzdDp0ZXN0')])
        self.assertStatus('200 OK')
        self.assertBody("Hello test, you've been authorized.")

    def testDigest(self):
        self.getPage("/digest/")
        self.assertStatus(401)

        value = None
        for k, v in self.headers:
            if k.lower() == "www-authenticate":
                if v.startswith("Digest"):
                    value = v
                    break

        if value is None:
            self._handlewebError(
                "Digest authentification scheme was not found")

        value = value[7:]
        items = value.split(', ')
        tokens = {}
        for item in items:
            key, value = item.split('=')
            tokens[key.lower()] = value

        missing_msg = "%s is missing"
        bad_value_msg = "'%s' was expecting '%s' but found '%s'"
        nonce = None
        if 'realm' not in tokens:
            self._handlewebError(missing_msg % 'realm')
        elif tokens['realm'] != '"localhost"':
            self._handlewebError(bad_value_msg %
                                 ('realm', '"localhost"', tokens['realm']))
        if 'nonce' not in tokens:
            self._handlewebError(missing_msg % 'nonce')
        else:
            nonce = tokens['nonce'].strip('"')
        if 'algorithm' not in tokens:
            self._handlewebError(missing_msg % 'algorithm')
        elif tokens['algorithm'] != '"MD5"':
            self._handlewebError(bad_value_msg %
                                 ('algorithm', '"MD5"', tokens['algorithm']))
        if 'qop' not in tokens:
            self._handlewebError(missing_msg % 'qop')
        elif tokens['qop'] != '"auth"':
            self._handlewebError(bad_value_msg %
                                 ('qop', '"auth"', tokens['qop']))

        # Test a wrong 'realm' value
        base_auth = (
            'Digest '
            'username="test", '
            'realm="wrong realm", '
            'nonce="%s", '
            'uri="/digest/", '
            'algorithm=MD5, '
            'response="%s", '
            'qop=auth, '
            'nc=%s, '
            'cnonce="1522e61005789929"'
        )

        auth = base_auth % (nonce, '', '00000001')
        params = httpauth.parseAuthorization(auth)
        response = httpauth._computeDigestResponse(params, 'test')

        auth = base_auth % (nonce, response, '00000001')
        self.getPage('/digest/', [('Authorization', auth)])
        self.assertStatus(401)

        # Test that must pass
        base_auth = (
            'Digest '
            'username="test", '
            'realm="localhost", '
            'nonce="%s", '
            'uri="/digest/", '
            'algorithm=MD5, '
            'response="%s", '
            'qop=auth, '
            'nc=%s, '
            'cnonce="1522e61005789929"'
        )

        auth = base_auth % (nonce, '', '00000001')
        params = httpauth.parseAuthorization(auth)
        response = httpauth._computeDigestResponse(params, 'test')

        auth = base_auth % (nonce, response, '00000001')
        self.getPage('/digest/', [('Authorization', auth)])
        self.assertStatus('200 OK')
        self.assertBody("Hello test, you've been authorized.")

{'content_hash': 'e691a49f43af1c12520097be0f861252', 'timestamp': '', 'source': 'github', 'line_count': 195, 'max_line_length': 77, 'avg_line_length': 32.6, 'alnum_prop': 0.515966650935976, 'repo_name': 'CodyKochmann/pi-cluster', 'id': '8be48b6bfb4e7b43e4ccf1835ceb3bf4c3305392', 'size': '6357', 'binary': False, 'copies': '5', 'ref': 'refs/heads/master', 'path': 'software/src/cherrypy/test/test_httpauth.py', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'CSS', 'bytes': '17'}, {'name': 'HTML', 'bytes': '524'}, {'name': 'Python', 'bytes': '1275353'}, {'name': 'Shell', 'bytes': '569'}]}


Unarma è un qualsiasi dispositivo, strumento meccanico o elemento di natura chimica, nucleare o elettromagnetica che venga utilizzato allo scopo di offendere oppure sia progettato per la difesa personale dell'utilizzatore.

In linea puramente teorica, qualunque oggetto può essere utilizzato come arma, anche se chiaramente alcuni possono risultare più efficaci o idonei allo scopo rispetto ad altri. Da un punto di vista normativo e concettuale si distingue generalmente fra "arma propria" e "arma impropria", cioè fra oggetti progettati e creati appositamente per essere usati come armi e oggetti originariamente destinati invece ad altra funzione, che in un determinato frangente vengono usati come armi.

Storia

Preistoria ed età della pietra

La clava, da molti storici viene ritenuta la prima arma e quindi la più antica arma fabbricata dall'uomo. Vennero ben presto la mazza un bastone appuntito con corno, e poi le scuri, i coltelli come le daghe, le lance, gli archi e le frecce costruite con selci lavorate o come in uso nelle civiltà precolombiane, in america, con schegge di ossidiana. Con l'uso dei metalli la varietà, tanto da offesa, quanto da difesa, si accrebbe rapidamente e ne nacque la prima suddivisione in difensive e offensive, le quali presero forme e i nomi più svariati. Nell'età della pietra si fabbricarono lame, coltelli, scuri di selce, e mazze semplici o formate di un bastone spaccato a una delle estremità, avente dentro lo spacco una pietra tenuta a posto con una legatura fatta di strisce di corteccia di albero o con una cordicella fatta di minugia attorcigliata.

Età antica
Parecchi storici sostengono che le macchine da lancio o da getto (baliste, catapulte) furono usate per prime dalle civiltà orientali i quali già le adoperavano da parecchi secoli quando, poco prima di Pericle, i Greci ne appresero l'uso. Invece, secondo Plutarco la macchina da lancio sarebbe originaria della penisola italiana e risalirebbe al IV secolo a.C.; i Greci l'avrebbero importata dalla Sicilia, che era già allora centro di sviluppatissima civiltà, anche militare. Comunque è certo che Ciro, che fu uno dei più audaci e geniali condottieri della storia antica, adoperò ampiamente la balista.

Nell'antica Grecia le macchine da getto ebbero diffusione dopo la guerra contro Serse e quella del Peloponneso, e vennero perfezionate da Filippo II di Macedonia e Alessandro Magno, i quali adoperarono dei parchi costruiti e diretti da Polido e Diodato. Questi parchi servivano esclusivamente per gli assedi, soltanto Alessandro fece il primo tentativo per utilizzarli in operazioni di campagna contro i Traci e, nella spedizione asiatica, mise in campo un'artiglieria eccellente, baliste e catapulte, di cui erano totalmente sprovvisti i Persiani e che provò le sue alte qualità tecniche negli assedi di Alicarnasso e di Tiro. Traiano utilizzò ampiamente le macchine da guerra anche sul campo di battaglia, in particolare la carroballista.

Va rilevato che dalle macchine da getto gli Elleni trassero scarso rendimento; a ciò contribuì l'insuccesso della seconda battaglia di Mantinea, durante la guerra del Peloponneso. La hasta nella civiltà romana era lunga circa metri 1,75, quanto l'altezza di chi la portava il quale era chiamato hastatus. Nei secoli XV, XVI e XVII si chiamò picca ed era per la fanteria molto lunga, facendo riscontro all'antico contus, arma propria dei cavalieri o all'antica sarissa della fanteria dell'esercito macedone.

Medioevo ed età moderna
Durante il medioevo e nell'età moderna incominciarono ad apparire le macchine corazzate e le armi da lancio. Tra le armi di difesa, si ricordano scudi e armature: in particolare, si attribuisce al capitano di ventura Mostarda da Forlì (XIV-XV secolo) l'introduzione dell'uso di armature interamente di ferro, anziché in cuoio, come si faceva fino ad allora. Le milizie medioevali usavano anche le cosiddette chiaverine,  nome dell'arma derivato da una parte di essa (l'asta) che portava in cima una cuspide di forma e materiale variabili. L'invenzione delle armi da fuoco e la loro applicazione alla guerra fece diminuire e quasi totalmente abbandonare le armi difensive personali.

Una prima grande svolta nella fabbricazione e nell'uso delle armi in Europa si ebbe nel XIV secolo con l'affermarsi dell'utilizzo bellico della polvere da sparo; vennero così costruite le prime armi da fuoco, che sfruttavano come forza propulsiva per il lancio di proiettili proprio i gas generati dalla deflagrazione della polvere da sparo quando questa veniva incendiata; uguale influsso ebbero gli approfondimenti degli studi sulla balistica. Il primo archibugio fu costruito in Spagna nel 1450., altre armi che si diffusero nel periodo furono colubrine, archibugi, moschetti, spingarde, pistole.

Tra le artiglierie del periodo, oltre ai primi tipi di armi lanciate a mano come bombe e granate, ci furono le bombarde. Le armi da fuoco portatili presero fin dall'inizio vari nomi, a seconda dell'epoca di costruzione, della forma, dei meccanismi presenti. Lo stesso avvenne per le artiglierie.

Il XIX e XX secolo
Con le scoperte scientifiche del XIX secolo e del XX secolo, alle cosiddette armi convenzionali si sono via via aggiunte o sostituite armi più sofisticate che fanno ricorso a tecnologie avanzate basate sull'uso della chimica (armi chimiche, con veleni o tossine), della biologia (armi batteriologiche, con ceppi di batteri o di virus letali), dell'energia nucleare (armi nucleari, come ad esempio la bomba atomica e la bomba H).

Classificazione
Con il progredire e l'evolversi delle tecnologia si sono andate sviluppando e affermando diversi tipi di armi, che possono essere variamente classificate.

Arma contundente

Sono delle armi - generalmente utilizzate nel combattimento corpo a corpo - solitamente in grado di infliggere ferite e lesioni, e solo in particolari casi di uccidere. Esse si basano sul principio dell'urto col bersaglio e per questo, sono chiamati anche armi da botta e ne sono tipici rappresentanti i bastoni, i martelli, le mazze, le clave. Altro esempio di tali armi, utilizzato in età antica e durante il medioevo, era il mazzafrusto.

Armi bianche

Sono tali armi ma anche oggetti che provocano danni al bersaglio se impugnati e azionati dall'uomo con la sola forza fisica anch'esse solitamente utilizzate nel combattimento corpo a corpo. In tale categoria possono essere ricomprese anche le armi contundenti; ma specificamente rispetto a queste incorporano lame. Quest'ultima è un pezzo di metallo di forma adeguata che presenta una o più parti affilate chiamate "filo". Le lame possono essere più adatte a tagliare (in questo caso si parla di armi da taglio e ne sono tipici rappresentanti le spade, i coltelli, le sciabole e le asce) o a colpire di punta per penetrare nel bersaglio (da qui la nascita del termine armi da punta), come i pugnali o le lance, le picche e le baionette: a questo scopo, alcune armi da punta non prevedono nemmeno la presenza del filo sulla lama, ma hanno solamente la punta acuminata necessaria per penetrare e/o sfondare (come alcuni stiletti, i fioretti, i "centodieci", il "becco di corvo").

Si possono inoltre distinguere le armi bianche secondo la dimensione in corte, medie e lunghe. Le armi bianche corte sono occultabili e generalmente non superano la trentina di centimetri: in questa categoria si possono catalogare i coltelli, i pugnali, gli stiletti, le daghe corte, le accette da lancio. Le armi bianche medie erano le tipiche armi individuali da guerra da usare a corta distanza prima dell'avvento delle armi da fuoco: spade, sciabole, asce da guerra ecc.

Sono armi bianche lunghe, altrimenti dette inastate o immanicate, quelle poste al termine di un bastone (asta) che ne diventa il mezzo per impugnarle (manico) e per aumentare la distanza di efficacia delle armi stesse: la categoria ricomprende lance, picche, alabarde, giavellotti. Con armi d'asta o armi in asta si indicano appunto tutte le armi che hanno un manico lungo da due a più metri e permettono di colpire l'avversario a qualche distanza continuando a impugnarle (seppure alcune sia possibile anche lanciarle, tipo il giavellotto). L'acquisto di tali armi è riservato solo a coloro in possesso di porto d'armi in corso di validità o in mancanza da nulla osta della questura. Si ricorda che qualsiasi lama con doppio filo è considerata arma da guerra pertanto non esistono autorizzazioni civili che permettano anche il solo acquisto di tali armi.

Armi da lancio
Sono armi da lancio quelle armi che, sempre grazie alla forza fisica dell'uomo e in abbinamento a dispositivi meccanici (ma sempre caricati dalla forza del lanciatore) servono per lanciare - anche a distanze considerevoli - proiettili di vario tipo come pietre, frecce, quadrella (arco, balestra, trabucco, fionda, scorpione, balista, carroballista), o che vengono esse stesse lanciate (giavellotto, asce da lancio, coltelli da lancio).

A seconda delle dimensioni e del numero di persone necessarie al proficuo utilizzo di queste armi, si ha la distinzione tra armi da lancio individuali (tutte quelle lanciate direttamente come giavellotto, asce da lancio, coltelli da lancio, nonché quelle che lanciano proiettili come arco, fionda, balestra, cerbottana) e armi di artiglieria (ballista, catapulta, trabucco, onagro e carroballista).

Armi da fuoco

Le armi da fuoco si possono dividere, anche in rapporto alle loro dimensioni e alla loro tipologia, in armi portatili (o leggere) (ad esempio pistola, fucile), armi di artiglieria (cannone, mortaio) e in armi esplodenti (bombe, mine, granate).

Nella categoria rientrano le armi che lanciano proiettili contenenti in sé energia propulsiva (lanciarazzi come il bazooka o il sistema MLRS, lanciamissili come il FIM-92 Stinger): tali armi sono sostanzialmente dei supporti di lancio per armi esplodenti che usano il principio del razzo per la loro stessa propulsione, altre armi da fuoco non tradizionali sono quelle elettriche, dove tramite una corrente si genera un campo elettromagnetico che accelera il proiettile, come nel caso del cannone a rotaia e del cannone di Gauss.

Armi non letali

Le armi non letali (in inglese non-lethal weapon) o inabilitanti sono particolari tipi di armi, atte a fermare o comunque bloccare persone, masse di persone, materiali o mezzi. Spesso sono usate in operazioni anti-sommossa. Questo tipo di armi colpiscono, puniscono e scoraggiano i bersagli, ma in teoria non dovrebbero uccidere. Solitamente questo tipo di armi utilizzano le moderne tecnologie nel campo dell'elettronica, l'optoelettronica, l'acustica, la chimica, la biologica, la medicina e la meccanica.

Alcuni tipi di queste armi sono:

 il Taser, pistola di stordimento che emette delle scariche elettriche
 il Long Range Acoustic Device, un cannone sonoro che sfrutta le onde acustiche
 i beanbags (letteralmente sacchetti di fagioli, ossia munizioni in cal.12 il cui proietto è costituito da pallettoni in gomma)
pistole laser che causano una cecità provvisoria

Armi esplosive e a propulsione

Sono armi che sfruttano la potenza generata dalla carica di esplosivo che incorporano, per generare danni a persone e cose.
Questa particolare categoria di armi da fuoco, costituita da armi esplodenti, nasce per danneggiare bersagli molto estesi o molto grandi, come edifici, macchinari, automezzi, mezzi corazzati, navi eccetera: generalmente non vengono usate da singoli uomini (ci sono eccezioni, come le bombe a mano, i lanciarazzi RPG e alcuni lanciamissili SAM spalleggiabili), ma lanciate da cannoni o sganciate da aerei o navi, o da appositi veicoli di terra e si differenziano tra di loro soprattutto per i diversi modi di arrivare sul bersaglio; per tale differenziazione avremo quindi:

 Mine: armi esplodenti "da posa", ovvero ordigni esplosivi che vengono sotterrati nel terreno o lasciati in mare in attesa che sia il bersaglio ad arrivare in prossimità dell'arma facendola esplodere e ricevendone i danni. Esistono tuttavia anche mine che vengono azionate quando vengono toccate, e sono dette pappagalli verdi, oppure il nome originale: pfm1. Nel caso delle mine terrestri, si hanno mine antiuomo (piccole e leggere, da posare in grandi quantità) e mine anticarro (più grandi delle mine antiuomo in quanto pensate per danneggiare veicoli corazzati) oltre che mine da demolizione (sono cariche esplosive che vengono posate direttamente da operatori specializzati sui bersagli o sulle opere edili da distruggere). Nel caso delle mine navali, queste possono essere galleggianti, ancorate sul fondo marino (se questo non è troppo profondo) e trattenute da catene in modo da rimanere sott'acqua a determinate profondità o addirittura, se "intelligenti", lasciate sul fondo lasciando il compito dell'affioramento alla mina stessa (che lo farà nel momento in cui i suoi sensori rilevano l'avvicinarsi di una nave avversaria). I tutti i casi (sia per mine terrestri sia per mine marine), l'esplosione della carica esplosiva può essere attivata in diversi modi, a seconda del tipo di mina: dalla pressione a seguito del contatto con il bersaglio, da un comando elettrico o radiotrasmesso, dallo strappo di appositi fili-trappola in tensione o dal segnale generato da sensori di prossimità oltre che dal semplice scadere di un tempo prefissato. Al giorno d'oggi, 133 paesi nel mondo hanno firmato il trattato di Ottawa: questo trattato fa sì che questi paesi che hanno aderito non fabbrichino più le mine antiuomo.
 Bombe a mano (o granate): armi esplodenti "da lancio" che vengono tirate manualmente dal singolo soldato. Affinché la detonazione avvenga in prossimità del bersaglio, l'ordigno è dotato di un dispositivo di innesco che può essere "con ritardo a tempo" (per cui l'esplosione avviene dopo un determinato periodo di tempo dal momento che si è armata la bomba, come nel caso della bomba a mano OD 82 in dotazione attuale all'Esercito Italiano) o "a percussione" (per cui l'esplosione avviene quando la bomba impatta contro un ostacolo, come nel caso della bomba a mano SRCM 35 in dotazione all'E.I. fino agli anni novanta).
 Bombe d'aereo: armi esplodenti "da caduta", ovvero ordigni esplosivi che vengono sganciati da velivoli e che arrivano sul bersaglio "in caduta libera". Per attivare la detonazione della carica esplosiva, anch'esse possono essere dotate di spolette che permettono l'esplosione al contatto con il bersaglio o con un tempo di ritardo prefissato. I recenti progressi tecnici e tecnologici hanno permesso la nascita prima delle "bombe guidate" e poi delle "bombe intelligenti": le bombe guidate (dette anche guided bomb) sono ordigni di caduta dotati di alcune appendici aerodinamiche mobili che permettono di modificare la traiettoria descritta dalla bomba durante la sua caduta, traiettoria che viene variata tramite comandi o segnali dall'esterno (ne sono un esempio le bombe a guida laser, a guida TV o semplicemente radiocomandate). Le bombe cosiddette intelligenti (dette anche smart bomb) in più rispetto alle bombe guidate, sono dotate di sensori di diverso tipo e sono autonome da segnali esterni per la loro direzionalità in quanto, una volta sganciate, sono loro stesse a identificare il bersaglio e a dirigervisi contro in modo autonomo. Esistono inoltre anche bombe a submunizionamento (bombe a grappolo) che hanno al loro interno un certo numero di ordigni di dimensioni più piccole che vengono rilasciate prima dell'impatto al suolo, in modo da coprire aree di maggiori dimensioni.
 Granate (o proietti d'artiglieria): armi esplodenti "da lancio" che arrivano sul bersaglio sfruttando la forza propellente di una carica esplosiva fatta detonare dietro al proietto all'interno di una canna di un pezzo d'artiglieria (che può essere un mortaio, un cannone o un obice). Vi sono diversi tipi di munizioni per artiglieria (a frammentazione, ad alto esplosivo o HE, a carica cava o HEAT, fumogeni, incendiari) per coprire diverse esigenze e tipi di intervento, compresi proietti "a submunizionamento" che rilasciano granate più piccole prima dell'impatto sulla zona bersaglio: in tal modo si possono coprire con pochi colpi aree più vaste con ordigni specifici per svariate esigenze. Inoltre, come nel caso delle "bombe", la moderna tecnologia ha portato a sviluppare anche ordigni d'artiglieria "intelligenti" che hanno un qualche sistema di "autoguida" per dirigersi in modo più o meno autonomo sul bersaglio migliorando enormemente la precisione del tiro (un esempio di tale tipo di munizionamento sono i proiettili in corso di sviluppo c/o la ditta costruttrice italiana OTO Melara per il loro uso nei pezzi navali da 76 mm e da 127 mm nel ruolo antiaereo e controcosta)
 Razzi: armi esplodenti "da lancio" che sfruttano il motore a razzo incorporato per dirigersi verso il bersaglio. In queste armi non sono presenti sistemi di guida per variarne la traiettoria balistica (anche se la moderna tecnologia permette la costruzione di testate belliche che contengono più "submunizioni" che possono anche avere un sistema di guida autonomo), per cui occorre calcolare esattamente la traiettoria che seguiranno prima di lanciarli, altrimenti non si colpirà il bersaglio. I razzi possono essere per uso d'artiglieria, (come per esempio nei sistemi lanciarazzi russi Katjuša della seconda guerra mondiale o come nei sistemi moderni MLRS o Firos 25 e 50), per uso individuale (come quelli a carica cava per uso anticarro sparati dal Bazooka americano o dal Panzerschreck tedesco nella II GM, nonché dai più moderni Carl Gustav svedesi o dai sistemi AT4 svedesi/americani) e per uso aereo (i razzi sparati da aerei ed elicotteri, normalmente verso bersagli di superficie).
 Missili: esattamente come i razzi, sono armi esplodenti che sfruttano il proprio motore per dirigersi verso il bersaglio; sono però dotate di sistema di guida (può essere sia autonomo sia dipendente dall'esterno, così come può essere misto con entrambe le possibilità di guida) oltre che di superfici aerodinamiche mobili: questo permette di dirigersi anche verso bersagli che effettuano movimenti random non preventivabili e in ogni caso, possono correggere la propria traiettoria durante il volo di avvicinamento raggiungendo una precisione enorme. A seconda della piattaforma di lancio e del tipo di bersaglio per la distruzione del quale sono stati costruiti, avremo i missili terra-aria o SAM (Surface to Air Missile) che dal suolo vengono lanciati per abbattere aerei nemici, missili aria-suolo o AGM (Air to Ground Missile) che viceversa, vengono lanciati dai velivoli per colpire bersagli terrestri, missili antinave o ASM (Anti Ship Missile) nati per colpire e possibilmente affondare bersagli navali, missili terra-terra nati per colpire bersagli terrestri partendo da lanciatori terrestri e infine i missili aria-aria o AAM (Air to Air Missile) che vengono lanciati da velivoli per colpire altri velivoli.

Armi di distruzione di massa

Sono armi progettate per causare distruzione in un ampio raggio geografico; In italiano è d'uso la dizione armi NBC dalle iniziali Nucleari, Batteriologiche, Chimiche. In inglese la sigla più usata è WMD, Weapon of Mass Destruction (arma di distruzione di massa), ma sono usati anche NBC e ABC (dove "A" sta per Atomic).

Lo scopo di queste armi non è tanto quello di colpire un obiettivo preciso quanto di distruggere quanti più edifici e mezzi e/o uccidere quante più persone possibile, indiscriminatamente e senza alcuna distinzione fra militari e civili: l'area colpita da esse è infatti tanto vasta, e gli effetti tanto duraturi nel tempo, da impedire il ritorno a una vita normale nell'area colpita per anni o per decenni, da parte di chiunque. Vengono anche definite armi della fine del mondo, perché un loro uso massiccio su vasta scala, per esempio in un'ipotetica terza guerra mondiale, avrebbe una buona probabilità di provocare l'estinzione della specie umana e di buona parte delle piante e degli animali superiori dal pianeta. L'utilizzo più comune di tali armi è la deterrenza, ovvero non sono fatte per essere usate ma per minacciare ritorsioni o attacchi.

Armi improprie

Come detto, sono considerati armi improprie oggetti costruiti con uno scopo utilitario, diverso da quello dell'offesa alla persona.

L'età contemporanea offre molti oggetti che posseggono un potenziale offensivo, e che quindi si prestano a diventare armi improprie. Si possono citare coltelli e altri arnesi da cucina, sostanze chimiche sia di sintesi sia naturali, utilizzate per i motivi più vari e che possono essere usate per nuocere a una persona, automobili e altri mezzi di trasporto con i quali è possibile provocare volontariamente incidenti, elettrodomestici, l'energia elettrica sia domestica sia industriale: in breve è un'arma impropria qualunque strumento costruito per uno scopo non offensivo ma che può essere usato come arma qualora lo si voglia.

Armi difensive
Vengono chiamati impropriamente armi (visto che non servono per offendere) difensive passive quegli oggetti indossabili atti a proteggere l'indossatore, per cui sono chiamate anche protezioni individuali. Quelle antiche, sono la corazza, l'elmo, lo scudo e tutte le altre parti che difendevano la persona da capo a piedi. Esse erano di forme svariatissime a seconda dell'epoca di costruzione e della nazione.

Quelle moderne si riducono all'elmetto, adottato per la prima volta nella prima guerra mondiale da tutte le nazioni. Durante quel conflitto, vennero usati anche "scudi" individuali che proteggevano gli uomini che avevano il compito di avvicinarsi alle trincee nemiche per tagliare il filo spinato che le proteggeva, oltre a venire impiegate anche corazze metalliche a forma di corpetto per proteggere "Arditi assaltatori" e "guastatori": da queste corazze, impiegando nuovi materiali quali Kevlar e piastre in ceramica balistica, si è giunti ai moderni giubbotti antischegge e ai giubbotti antiproiettile.

Altro elemento importante è stato il sacchetto a terra che si trasporta vuoto e si riempie sul posto per creare una postazione difensiva fissa, utilizzato nelle trincee e nelle fortificazioni.

Armi sportive

Sono armi concepite per attività sportiva, quali il tiro a segno. Queste armi si contraddistinguono da quelle da guerra o quelle comuni per la loro meccanica più sofisticata, i sistemi di mira più precisi, le impugnature regolabili e altri accorgimenti che ne fanno delle armi adatte all'esercizio dello sport del tiro. Esempio tipico sono le armi ad aria compressa.

Armi da caccia

Le armi da caccia in Italia possono essere detenute con regolare denuncia in numero illimitato.
Sono armi da caccia tutte le armi lunghe che camerano cartucce di calibro uguale a 5,6 mm e bossolo lungo almeno 40 mm e quelle di calibro superiore senza limite alla misura del bossolo. Non sono armi da caccia le armi corte e quelle lunghe di calibro inferiore a 5,6 mm.

Armi autonome
Il recente sviluppo dell'intelligenza artificiale e della robotica ha portato alla creazione di armi autonome cioè dotate di una maggiore o minor autonomia decisionale ad esempio le mine navali intelligenti e i robot killer .Trattandosi di tecnologie recenti in forte sviluppo non sono sottoposte ancora a limitazioni legislative.Nel luglio 2015 scienziati di fama internazionale come Stephen Hawking, Elon Musk, Max Tegmark hanno pubblicato una lettera aperta per denunciare i pericoli della corsa agli armamenti di armi autonome che scelgono e colpiscono i loro bersagli senza l'intervento umano.

Armi proibite in guerra
Sono armi che sono proibite in base a trattati internazionali, la cui violazione è considerata un crimine di guerra, punibile da un tribunale internazionale alla fine delle ostilità.

Divieti analoghi esistevano fin nelle più antiche usanze di guerra, come risulta dai codici indiani ed ebraici. Quei codici consideravano da proibirsi le frecce dentate e le armi con la punta avvelenata e facevano divieto di uccidere gli inermi o coloro che si arrendevano, e di incendiare o distruggere senza assoluta necessità.. Era inoltre, nel medioevo, proibito l'utilizzo dell'arbalesta, o comunque lo si riteneva scorretto, in quanto poteva uccidere facilmente un cavaliere con molta più esperienza del tiratore.

Sistema d'arma
Per sistema d'arma si intende l'associazione tra l'arma vera e propria e un dispositivo servente, ad esempio, un veicolo (anche convenzionale), contenitore, apparecchiatura di osservazione (radar) o personale di servizio, adatti alle condizioni di battaglia, che permettono di aumentare le prestazioni dell'arma, rendendola ad esempio mobile o aumentando il numero di colpi. Ad esempio, un cavaliere con la corazza, il suo scudiero e rispettivi cavalli costituiscono un sistema d'arma.

Altrettanto lo sono un cannone, il camion che lo traina, altri camion con le munizioni, le munizioni, gli addetti ad un pezzo d'artiglieria ed eventuali elicotteri o jeep di avvistamento nella prima linea, e le radio per comunicare. Un sommergibile nucleare, con i suoi missili SLBM sono un sistema d'arma. Lo sono anche missili come l'SS-26 Stone e il suo lanciatore, così come anche il laser Boeing YAL-1 e l'aereo che lo contiene, derivato dal convenzionale Boeing 747.

La legislazione internazionale

In base a diversi trattati, accordi e convenzioni internazionali, l'utilizzo di particolari armi può essere limitato oppure vietato. Ricordiamo in proposito la dichiarazione di San Pietroburgo del 1868, proibisce i proiettili esplodenti di peso inferiore a quattrocento grammi. Tra i trattati più famosi abbiamo la convenzione dell'Aia del 1899, la convenzione dell'Aia del 1907, le varie convenzioni di Ginevra, nel trattato navale di Washington del 1922 ed il protocollo di Ginevra del 1925 sul divieto dell'impiego di gas asfissianti, velenosi o simili e di mezzi batteriologici in guerra. Nella seconda metà del XX secolo dopo la guerra del Vietnam è stato proibito anche l'uso del napalm; si ricordino poi la convenzione delle Nazioni Unite su certe armi convenzionali del 1980, della convenzione sulle armi chimiche del 1993 e del trattato di Ottawa del 1997 sull'utilizzo delle mine antiuomo e, in tema di traffico di armi, la convenzione delle Nazioni Unite contro la criminalità organizzata transnazionale stipulata a Palermo nel dicembre del 2000.

Le legislazioni statali

Le armi generalmente sono usate dalle forze armate e dalle forze di polizia, con specifiche previsioni, ma tutti gli Stati nel mondo posseggono legislazione in materia; come ad esempio in tema di possesso illegale di armi, traffico di armi e per la possibilità di utilizzo da parte di privati, previo rilascio di una particolare autorizzazione, detta genericamente licenza di porto d'armi.

Italia

La 18 aprile 1975, n. 110 qualifica come tale tipologia di armi - chiamandole armi da sparo tutte quelle armi in grado di lanciare un proiettile attraverso una canna, indipendentemente dall'utilizzo della combustione di polvere da sparo, comprese le armi ad aria compressa, ad eccezione di quelle con potenza inferiore a 7.5 joule.

La legge italiana non attribuisce al cittadino Ipso iure il diritto di portare o detenere armi, ma consente al Prefetto ed al Questore di autorizzarne l'acquisto, la detenzione o il porto in casi specifici; la giurisprudenza riconosce, in tale attività amministrativa, un alto grado di discrezionalità, in nome della tutela della sicurezza pubblica. Il rilascio delle autorizzazioni è subordinato all'accertamento della idoneità psichica del richiedente, certificata dal servizio sanitario nazionale.

Note

Voci correlate

 Arma bianca
 Arma biologica
 Arma contundente
 Arma non letale
 Arma da fuoco
 Armi leggere
 Armeria (armi)
 Armi a microonde
 Arma di distruzione di massa
 Armi da caccia
 Armi nucleari
 Armi chimiche
 Artiglieria
 Autodifesa
 Bomba
 Danno
 Granata (arma)
 Licenza di porto d'armi
 Munizioni
 Missile
 Oplologia
 Ordigno esplosivo improvvisato
 Possesso illegale di armi
 Traffico di armi
 Varmint

Altri progetti

Collegamenti esterni

{'title': 'Arma', 'url': 'https://it.wikipedia.org/wiki/Arma', 'language': 'it', 'timestamp': '20230320'}


Description 14 Delivery orders and correspondence for August 8-14, 1894.
H.K. White, Reynolds, J. Dowling, Ford, Bruff, Wellenkamp, and Thomas contributors. Includes sears for Springfield U.S. musket, Shoverling, Daly & Gales, muskets mod 42, musket tumbler pin, tumbler screws, Hotchkiss magazine rifles, Springfield rifles, McKeever cartridge boxes, non com off belt and plates, steel scabbard, large frog, muskets mod 22, Wm. Koppe, Bryan, Tex., Jas Bown & Sons, Pittsburgh, Pa.

{'timestamp': '2019-04-26T16:52:22Z', 'url': 'http://library.centerofthewest.org/cdm/ref/collection/SHG/id/5783/', 'language': 'en', 'source': 'c4'}


«Сільський пейзаж з церковною вежею» () — один з небагатьох «чистих» пейзажів французького художника Едуара Мане.

Едуар Мане не одразу став художником. Його батько, прихильник буржуазних смаків і тогочасних добропорядних настанов, наполягав на отриманні сином престижного фаху, яким фах художника не вважався, сприймався несерйозним і не гідним сина. Тому Едуар деякий час випробував себе як моряк. Саме морські пейзажі (марини) і переважають в творах художника, що нечасто звертався до пейзажної тематики. Хоча пейзажні замальовки зустрічаються серед малюнків та графічних спроб художника. Дивує економним використанням художніх засобів пейзажний фронтиспіс з фігурою фавна, створений художником до одної з поем Стефана Малларме. Навіть картина «Венеція. Причальні стовпи на Гранд Каналі» поєднує зображення приморського міста і затоки (1875, Сан Франциско).

«Сільський пейзаж з церковною вежею» — зразок неморського пейзажу, досить рідкий в творчому надбанні художника. Створений в імпресіоністичній манері в період, коли французький імпресіонізм ще робив перші кроки в мистецтві Франції.

Джерела
 Анри Перрюшо, «Едуард Мане», серия «Жизнь замечательных людей», М. «Молодая гвардия», 1976
 ЧегодаевА. Д. «Эдуард Мане», М, «Искусство», 1985 (рос)
 сборник «Западно-европейское искусство 2й половины 19 века», М, «Искусство»,1975 (рос)
 «100 офортов 16-19 вв. из собрания Гос. Эрмитажа», Л-М.,"Сов. художник", 1964 (рос)

Пейзажі
Музейні експонати
Картини за алфавітом
Картини Едуара Мане
Картини музею Ашмола


Емануель Шлехтер (псевд. Еман; 9 жовтня 1904 або 26 березня, Львів — 11 листопада 1943, Львів) — єврейсько-польський пісняр, автор текстів пісень, сценарист, сатирик, перекладач, співак, композитор і режисер.

Життєпис
Походив із полонізованої єврейської родини середнього достатку. Як доброволець (будучи ще гімназистом) боровся у війні з більшовиками 1920 року. Студіював право в Університеті Яна Казимира у Львові і водночас виступав у кабаре та театрах. Від початку був пов'язаний з Польським Радіо Львів, де виявив себе як мовний пурист, про якого колеги говорили: «більш польський, ніж поляки». Навіть прізвище своє записував згідно з польською транслітерацією: Szlechter. Близько 1933 року виїхав до Варшави.

Замордований окупантами разом з дружиною і сином у Янівському концентраційному таборі у Львові не пізніше 1943 р.

Доробок
У Варшаві став одним із найбажаніших авторів діалогів, сценаріїв, пісень. Брав участь у створенні майже тридцяти фільмів, в тому числі трьох фільмів Міхала Вашинського (Michał Waszyński) про львівських батярів — Щепка і Тонька. Його пісні і нині відомі у Польщі, хоча прізвище автора текстів залишається в тіні.
 «Кожен може кохати» («Każdemu wolno kochać»),
 «А мені шкода літа» («A mnie jest szkoda lata»),
 «Трішки щастя в коханні» («Odrobinę szczęścia w miłości»),
 «Сексепіл» («Sexapeal»),
 «На дев'яту домовився з нею» («Umówiłem się z nią na 9-tą»).
«Львівські» пісні:
 «Тільку ві Львові» («Tylko we Lwowie»),
 «Серце батяра» («Serce batiara»),
 «Маю ґітару ві Львові куплену» («Mam gitarę kupioną we Lwowie», інша назва «Розспіваний Львів»(«Rozśpiewany Lwów») чи «Ми два обацвай») («My dwaj obacwaj»).

Джерела
 Adam Redzik. Jak twórca szlagierów wszech czasów nie został adwokatem — Rzecz o Emanuelu Schlechterze (1904—1943). w 110. rocznicę urodzin i 70. rocznicę śmierci. «Palestra». 1–2, s. 245—255, 2014.
 Skocz do: a b c d e Schlechter, Emanuel. Biografia. W: Biblioteka Polskiej Piosenki [on-line]. [dostęp 2014-09-16].
 Skocz do góry ↑ Tak: T. Lerski, Emanuel Schlechter: wspomnienie o autorze lwowskich piosenek, «Rocznik Lwowski» 1999, s. 101—107; tenże, Emanuel Schlechter. Wspomnienie o autorze piosenek, «Piosenka» 2006, R. 1, z. 2, s. 95–98; tenże, Szlechter Emanuel, «Polski Słownik Biograficzny», T. XLVIII/3, z. 198, s. 352—353.
 Redzik, Emil Henryk Szlechter (1906—1995) — w dwudziestą rocznicę śmierci, «Palestra» 2015, nr 1-2, s. 216.
 Tomasz S. Lerski: Emanuel Szlechter. W: Polski Słownik Biograficzny. T. 48. s. 351—353.
 Redzik, Emil Henryk Szlechter (1906—1995) — w dwudziestą rocznicę śmierci, «Palestra» 2015, nr 1-2, s. 216.
 Redzik, Jak twórca szlagierów wszech czasów nie został adwokatem — rzecz o Emanuelu Schlechterze (1904—1943). W 110. rocznicę urodzin i 70. rocznicę śmierci, «Palestra» 2014, nr 1-2, s. 245—255.

Примітки

Уродженці Львова
Поети XX століття
Піснярі
Померли у Львові


Bohumil Procházka (28. června 1909, Praha – 28. března 1963, Praha) byl český knihkupec a účastník protinacistického odboje.

První republika
Narodil se v rodině krejčího, který zahynul v ruském zajetí na východní frontě v roce 1915. Matka jako válečná vdova těžce sháněla obživu. Po vyučení u knihkupce a nakladatele Josefa Springera začal pracovat v nakladatelství Šolc a Šimáček. V roce 1938 se osamostatnil a zařídil si vlastní knihkupectví v Anglické ulici č. 4 v Praze na Vinohradech. Zároveň se připravoval na samostatnou nakladatelskou činnost. Knihkupecké povolání spojoval s láskou k četbě, kterou považoval za prostředek k sebevzdělání a k hlubšímu porozumění životu. Vážil si T. G. Masaryka a pod vlivem kazatele Františka Urbánka z Jednoty českobratrské (JČB), přítele prezidenta a jeho rodiny, opustil katolickou církev a stal se členem vinohradského sboru JČB (dnešní Církve bratrské). Byl členem Sokola a sdružení Akademická YMCA.

Odbojová činnost a uvěznění
V červnu 1939 ho přátelé z Akademické YMCA, Dr. Jaroslava Valenta a Dr. Rudolf Mareš (později zatčení, mučení a popravení), získali pro spolupráci v protinacistickém odboji. Stal se členem odbojové skupiny Petiční výbor Věrni zůstaneme (PVVZ), později začleněné do Ústředního vedení odboje domácího (ÚVOD). Jeho knihkupectví sloužilo jako „překladiště“ zpráv pro české rozhlasové vysílání exilové vlády v Londýně. V této „sběrně“ zpráv pro šifrování se také zprostředkovávaly schůzky odbojářů, předávaly peníze a balíčky na podporu postižených rodin, šířily tiskoviny.

Gestapo Bohumila Procházku zatklo 30. září 1940 a obvinilo jej (podle tehdejších zákonů) z „přípravy k velezradě“. Po osmi měsících strávených ve vyšetřovací vazbě ve věznici na Pankráci a častých výsleších v Petschkově paláci byl poslán do koncentračního tábora Sachsenhausen-Oranienburg, kde se stal 7. června 1941 häftlingem č. 37924. Mezi spoluvězni se tam setkal například s Ivanem Herbenem, Rudolfem Mertlíkem či Josefem Čapkem či s již dříve uvězněnými českými studenty. Také zde působil jako „knihovník“, pečoval tu o tajnou knihovničku českých knih doručovaných vězňům ilegálně v potravinových balíčcích.

Na sklonku války, počínaje 21. dubnem 1945, byli vězni vláčeni pochodem smrti přes Wittstock, Grabow až do Criwitz nedaleko Schwerinu, kde je v blízkosti fronty opustily stráže SS a osvobodila americká armáda. Odtud vězni putovali pěšky do Neubrandenburgu, odkud je nákladní auta odvezla zpět do vlasti. Bohumil Procházka se vrátil domů 6. června 1945.

Mezitím v Praze zahynula při spojeneckém náletu 14. února 1945 jeho matka a synovec, jeho byt byl zcela zničen. Knihkupectví zůstalo po jeho zatčení otevřeno, vedla jej jeho sestra Milada Zadáková.

Po válce
Po válce se oženil s Lydií Štifterovou (1946) a vrátil se ke knihkupeckému povolání. Jeho plány založit vlastní nakladatelství – v nichž ho podporoval jeho dlouholetý přítel, vynikající vinohradský nakladatel František Laichter – zmařil únorový převrat 1948. Komunistický režim Procházkovo knihkupectví zestátnil v roce 1950. Zpočátku mohl zůstat vedoucím svého bývalého podniku v Anglické ulici, později byl přeložen jako vedoucí Knihy do Žitné ulice č. 14. V roce 1960 onemocněl na následky strádání v koncentračním táboře rakovinou tlustého střeva a nemoci podlehl na jaře roku 1963.

Citát
„V koncentračním táboře byla česká kniha jako poklad v křišťálové skříňce. Stále skrývat a tajně rozněcovat jeho čistou záři.“ Bohumil Procházka, Knihkupec v koncentráku (neotištěná vzpomínka z 26.7.1945)

Odkazy

Reference

Literatura
 Miloslav HAVEL: Nezapomeňte na mladé knihkupce!, Národní listy, 6. 8. 1939.
 Jaroslav VOZKA: Hrdinové domácího odboje. Praha, Práce, 1946, 152 s. S. 70-71.
 Pavel JAVORNICKÝ: Vzpomínka na bratra Bohumila Procházku. Kostnické jiskry, 1964, č. 13, s. 4.
 Jan ŠTĚPÁN: Menší evangelické církve v nacistické okupaci 1939–1945. Kostnické jiskry, 14. 5. 1997.
 Jan ŠTĚPÁN: Menší evangelické církve v nacistické okupaci 1939–1945. In: Rok 1942 v českém odboji. Sborník příspěvků z vědecké konference. Praha, Český svaz bojovníků za svobodu, 1999. , s. 102-105.
 Prošli jsme v jeho síle: Evangelíci v čase druhé světové války. Uspořádala Milena Šimsová. 1. vyd. Praha, Kalich, 2003, 271 s. . S. 61-65.
 Pavel HOLEKA: Čistý, hluboce věřící muž: Bohumil Procházka 1909–1963. Evangelický týdeník-Kostnické jiskry, 2. dubna 2003.
 Kniha a národ 1939–1945. Redigoval Václav Poláček, 1. vyd., Praha/Litomyšl, Paseka, 2004, 384 s. . S 45, 232.
 Vladimír KRAJINA: Vysoká hra: Vzpomínky. 2. vyd., Praha, Eva-Milan Nevole, 280 s. S. 20.
 Milena ŠIMSOVÁ: V šat bílý odění. 1. vyd., Benešov, Eman, 2005, 255 s. . S. 150.
 Bronislava JANEČKOVÁ: Rok v dopisech. II. díl, Praha, Radioservis, 2009, 359 s. S. 222-224.
 Marta a Pavel HOLEKOVI: Cesta za neznámou fotografií vězně č. 37924. Zprávy Společnosti bratří Čapků, červen 2014, č. 113, s. 2.
 Marta a Pavel HOLEKOVI: Bohumil Procházka; Vinohradský knihkupec, in: Jana Bartošová: Nesmíme zapomenout; Jan Opletal a další oběti listopadu 1939; Nacistická perzekuce českých studentů během 2. světové války, Národní pedagogické muzeum a knihovna J. A. Komenského, Praha, 2015, str. 138-145.
 Pavel HOLEKA, Známí a neznámí hrdinové podzimu 1939 (Vinohradský knihkupec Bohumil Procházka), Evangelický týdeník, ročník 101, 2/2016.
 Marta a Pavel HOLEKOVI: Kniha jako osud. Nakladatel František Laichter a knihkupec Bohumil Procházka, Protestant, č. 9, roč. XXVII, 2016.

Související články
 Petiční výbor Věrni zůstaneme
 Ústřední vedení odboje domácího

Knihkupci
Osobnosti Petičního výboru Věrni zůstaneme
Vězni koncentračního tábora Sachsenhausen
Narození 28. června
Narození v roce 1909
Narození v Praze
Úmrtí 28. března
Úmrtí v roce 1963
Úmrtí v Praze
Muži

{'title': 'Bohumil Procházka', 'url': 'https://cs.wikipedia.org/wiki/Bohumil%20Proch%C3%A1zka', 'language': 'cs', 'timestamp': '20230320'}


<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="rc_voip_video">Video call</string>
    <string name="rc_voip_audio">Voice call</string>
    <string name="rc_voip_call_waiting">Waiting for accept calling invitation...</string>
    <string name="rc_voip_call_connecting">Connecting</string>
    <string name="rc_voip_call_busy">Busy line</string>
    <string name="rc_voip_call_no_response">No answer</string>
    <string name="rc_voip_call_hangup">Cancelled</string>
    <string name="rc_voip_call_network_error">Network connection is not reachable, please check it</string>
    <string name="rc_voip_call_interrupt">Cancelled</string>
    <string name="rc_voip_call_terminalted">Call ended</string>
    <string name="rc_voip_call_started">Call started</string>
    <string name="rc_voip_select_member">Select members</string>
    <string name="rc_voip_call_start_fail">Call is on. Try again later.</string>
    <string name="rc_voip_call_other">Other devices have been answered</string>

    <string name="rc_voip_audio_call_inviting">Invites you to voice call</string>
    <string name="rc_voip_video_call_inviting">Invites you to video call</string>
    <string name="rc_voip_video_ended">Video call ended</string>
    <string name="rc_voip_video_no_response">Video call no answer</string>
    <string name="rc_voip_audio_ended">Voice call ended</string>
    <string name="rc_voip_audio_no_response">Voice call no answer</string>
    <string name="rc_voip_mute">mute</string>
    <string name="rc_voip_hangup">Hang up</string>
    <string name="rc_voip_answer">Accept</string>
    <string name="rc_voip_camera">Camera</string>
    <string name="rc_voip_handfree">Speaker</string>
    <string name="rc_voip_disable_camera">Camera</string>
    <string name="rc_voip_enable_camera">Camera</string>
    <string name="rc_voip_participant_users">Members</string>
    <string name="rc_voip_mo_cancel">Cancelled</string>
    <string name="rc_voip_mo_reject">Declined</string>
    <string name="rc_voip_mo_no_response">No answer</string>
    <string name="rc_voip_mt_cancel">Cancelled</string>
    <string name="rc_voip_mt_reject">Declined</string>
    <string name="rc_voip_mt_no_response">No answer</string>
    <string name="rc_voip_call_time_length">Duration </string>
    <string name="rc_voip_mt_busy">Remote user my be busy. Try again later.</string>
    <string name="rc_voip_message_audio">[Voice call]</string>
    <string name="rc_voip_message_video">[Video call]</string>
    <string name="rc_voip_remote_switch_to_audio">Other user switched to voice call.</string>
    <string name="rc_voip_switch_to_audio">Switch to voice call.</string>
    <string name="rc_voip_float_window_not_allowed">Please enable floating windows</string>
    <string name="rc_call_on_going">Call in progress</string>
    <string name="rc_audio_call_on_going">Tap to continue as voice call in progress</string>
    <string name="rc_video_call_on_going">Tap to continue as video call is on</string>
</resources>

{'content_hash': '396c63f1efc7639c9c9db89f12582eb9', 'timestamp': '', 'source': 'github', 'line_count': 48, 'max_line_length': 107, 'avg_line_length': 62.854166666666664, 'alnum_prop': 0.707988067616838, 'repo_name': 'cosmos-chou/test', 'id': 'ade0b8542a9e7825f732b6331c91cb78f3b48f25', 'size': '3017', 'binary': False, 'copies': '1', 'ref': 'refs/heads/master', 'path': 'CallKit/src/main/res/values-en/rc_voipkit_string.xml', 'mode': '33188', 'license': 'mit', 'language': [{'name': 'Java', 'bytes': '1999648'}]}