Esempio n. 1
0
int Comando_Terminal_Local(int conexao,char *param,int tipo){
  int ret;
   if(tipo==CD){
	   if(ret=cd(param)==-1) printf("Diretório inexistente ou sem acesso\n");
   }
   else ls(param);
   
   if(param!=NULL) strcpy(param,"");
  return;  	     

}
Esempio n. 2
0
int popd(Stack *in){
	if(in->top == -1){
		return EXIT_FAILURE;
	}
	else{
		char *temp = in->stack[in->top--];
		cd(temp);
		free(temp);
		return EXIT_SUCCESS;
	}
}
Esempio n. 3
0
QString Paths::resourceDir(const QString& file)
{
  auto resourceDir = QDir(QGuiApplication::applicationDirPath());

#ifdef Q_OS_MAC
  resourceDir.cdUp();
  resourceDir.cd("Resources");
#endif

  return resourceDir.filePath(file);
}
TEST(CompressedMatrix, CopyConstructor)
{
    CompressedMatrix<int> ci(3, 3);
    ci[0][0] = 1;
    ci[1][1] = 2;
    ci[2][2] = 3;

    CompressedMatrix<double> cd(ci);

    EXPECT_EQ(ci, cd);
}
Esempio n. 5
0
//This tests touch and creat
//First test makes sure the mtime changes on a file that exists.
//Returns 0 if the time isnt greater than what it was before.
//Second test touches a file that doesnt exits, and therefore makes one.
//Checks the inode of the new file, and if isn't what is expected, returns zero.
//This second test checks both if touch and creat are working.
int touchTest()
{
  MINODE *test_mip = running->cwd;
  INODE *ip = NULL;
  int ino = 0;
  int old = 0;
  int expected1 = 28;

  strcpy(pathname, "");
  cd(pathname);
  test_mip = running->cwd;
  printf("\n\n-------- TESTING TOUCH FUNCTION --------\n\n");

  strcpy(pathname, "tiny");
  ino = getino(test_mip, pathname);
  test_mip = iget(dev, ino);
  ip = &test_mip->INODE;

  old = ip->i_mtime;
  printf("tiny's current mtime = %d\n", ip->i_mtime);
  printf("Testing >touch tiny\n");
  strcpy(pathname, "tiny");
  touch_file(pathname);
  printf("tiny's new mtime = %d\n", ip->i_mtime);

  if(ip->i_mtime > old)
    printf("TEST PASSED!\n\n");
  else
  {
    printf("TEST FAILED!\n\n");
    return 0;
  }


  test_mip = running->cwd;
  printf("Testing >touch newfile\n");
  strcpy(pathname, "newfile");
  touch_file(pathname);

  strcpy(pathname, "newfile");
  ino = getino(test_mip, pathname);
  printf("Expected ino of newfile = %d\n", expected1);
  printf("Actual ino of newfile = %d\n", ino);
  if (ino != expected1)
  {
    printf("TEST FAILED!\n\n");
    return 0;
  }
  printf("TEST PASSED!\n\n");

  printf("\nALL TOUCH TESTS PASSED!\n\n\n");
	return 1;
}
Esempio n. 6
0
int pushd(int argc, char** argv) {
	if (top==MAX_DIRECTORY_STACK) {
		fprintf(stderr,"%s: cannot pushd: directory stack full\n",shellname);
		return 1;
	} else {
		dstack[top]=getcwd(malloc(PATH_MAX),PATH_MAX); // push current directory to stack
		top++;
		cd(argc,argv); // change to requested directory
		dirs(1,NULL);  // stat stack status
	}
	return 0;
}
//big ass switchy thingy
int find_and_exec(const char * command_name, const char * parameters){
  int ret;
  if(command_name == NULL){
    return 0;
  }
  else if(strcmp(command_name,"pwd") == 0){
    return pwd();
  }
  else if(strcmp(command_name,"cd") == 0){
    return cd(parameters);
  }
  else if(strcmp(command_name,"echo") == 0){
    return echo(parameters);
  }
  else if(strcmp(command_name,"pushd") == 0){
    return pushd(parameters);
  }
  else if(strcmp(command_name,"popd") == 0){
    return popd();
  }
  else if(strcmp(command_name,"exit") == 0){
    exitc(parameters);
  }
  else if(strcmp(command_name,"set") == 0){
    printf("Did you mean export? If you are looking for windows try your walls\n");
    return 0;
  }
  else if(strcmp(command_name,"history") == 0){
    print_stack_lines(history);
    return 0;
  }
  else if(strcmp(command_name,"unsetenv") == 0){
    return unsetenv(parameters);
  }
  else {
    int pid = fork();
    if(pid == -1){return 1;}
    else if(pid == 0){
      if(parameters == NULL) {
        execlp(command_name,command_name,NULL);
      }
      else {
        execvp(command_name,split_spaces_cmd(command_name,parameters));
      }
    }
    else {
      wait(&ret);
      return ret;
    }
  }
  return 0;
}
Esempio n. 8
0
QDir createTestDir()
{
	auto tempDir = QDir::temp();
	
	QProcess process;
	process.start("rm -rf " + tempDir.filePath("test"));
	process.waitForFinished();
	
	tempDir.mkdir("test");
	tempDir.cd("test");
	
	return tempDir;
}
Esempio n. 9
0
void start(bool read_from_file)
{
	cd(""); // let shell starts from home

	if(read_from_file){
		// file processing functions should be called from here

		shell_loop(true);
	}
	else{
		shell_loop(false);
	}
}
Esempio n. 10
0
int execute_non_forking(char **subcmd){
	int retval;
	char *cmd = subcmd[0];
	char **args = &subcmd[1];
	if (strcmp(cmd, "exit") == 0) {
		retval = exit_shell();
	} else if (strcmp(cmd, "cd") == 0) {
		retval = cd(args[0]);
	} else {
		retval = 2;
	}
	return retval;
}
Esempio n. 11
0
/**
 * Quash entry point
 *
 * @param argc argument count from the command line
 * @param argv argument vector from the command line
 * @return program exit status
 */
int main(int argc, char** argv) { 
    command_t cmd; //< Command holder argument
      
    start();
    struct sigaction NULL_sa;
    struct sigaction sa;
    sigset_t mask_set;
    sigfillset(&mask_set);
    sigdelset(&mask_set,SIGINT);
    sigdelset(&mask_set,SIGTSTP);
    sa.sa_handler = catchChild;
    sigprocmask(SIG_SETMASK, &mask_set, NULL);
    //TODO: this is involved withe the error 10 problem. Removing it remedies the issue for now but breaks other things.
    sigaction(SIGCHLD, &sa,NULL);//child termination calls catchChild;

    setenv( "WKDIR", getenv("HOME"), 1 );

    puts("hOi! Welcome to Quash!");

    // Main execution loop
    while (is_running()) 
    {
        // NOTE: I would not recommend keeping anything inside the body of
        // this while loop. It is just an example.

        // The commands should be parsed, then executed.
        if( !get_command(&cmd, stdin) );
        else if (!strcmp(cmd.cmdstr, "q")||!strcmp(cmd.cmdstr, "exit")||!strcmp(cmd.cmdstr, "quit"))
            terminate(); // Exit Quash
        else if(!strcmp(cmd.execArgs[0], "set"))
            set(cmd);//set environment variables
        else if(!strcmp(cmd.execArgs[0], "echo"))
            echo(cmd);//echos environment variables
        else if(!strcmp(cmd.execArgs[0], "pwd"))
            pwd(cmd);//prints current working directory
        else if(!strcmp(cmd.execArgs[0], "cd"))
            cd(cmd);//changes the working directory
        else if(!strcmp(cmd.execArgs[0], "jobs"))
            jobs();//prints out a list of currently running jobs
        else if(!strcmp(cmd.execArgs[0], "kill"))
            killChild(cmd);//kills specified job
        else if (!strcmp(cmd.execArgs[0], "wait"))
            sleep(atoi(cmd.execArgs[1]));
        else if (strchr(cmd.cmdstr,'|')!= NULL)
            exec_pipes(cmd);//executes piped commands
        else 
            exec_cmd(cmd);//executes normal commands
    }

    return EXIT_SUCCESS;
}
Esempio n. 12
0
		 mkdir(char *dname){                                         //WORKS!!!
			 char *FileName;
			 struct NODE *temp;
			 temp = cwd;
			 strcpy(bname, basename(dname));
			 if(0 == strcmp(basename(dname), "/")){
				 //      printf("cannot create directory '/'");
				 return 0;
			 }
			 if(!dname || bname[0] == '.' || bname[0] == '/'){
				 return 0;
			 }
			 char *character = dirname(dname);
			 if(strcmp(character, ".")){
				 printf("%s\n", character);
				 if(cd(&temp, character) == 0){
					 printf("mkdir: cannot create directory '%s': directory does not exist\n", dname);
					 return 0;
				 };
			 }
			 //  printf("%s ###: ", character);
			 //  pwd(temp);
			 //  printf(" ###\n");
			 //  printf("Dir: '%s' File: '%s'\n",dname, bname);
			 if(temp->childPtr == NULL){      
				 temp->childPtr = (struct NODE *)malloc(sizeof(struct NODE));
				 strcpy(temp->childPtr->Name, bname);
				 temp->childPtr->parentPtr = temp;
				 strcpy(temp->childPtr->Type, "D");
			 }
			 else{
				 temp = temp->childPtr;
				 if(0 == strcmp(temp->Name, bname)){
					 printf("mkdir: cannot create directory '%s': directory exists\n", bname);
					 return 0;
				 }
				 while(temp->siblingPtr != NULL){
					 temp = temp->siblingPtr;
					 //   printf("%s != %s\n", temp->Name, dname);
					 if(0 == strcmp(temp->Name, bname)){
						 printf("mkdir: cannot create directory '%s': directory exists\n", dname);
						 return 0;
					 }
				 }
				 temp->siblingPtr = (struct NODE *)malloc(sizeof(struct NODE));
				 strcpy(temp->siblingPtr->Name, bname);
				 temp->siblingPtr->parentPtr = temp->parentPtr;
				 strcpy(temp->siblingPtr->Type, "D");
			 }
			 //printf("Directory: %s Created.\n", dname);
		 }
Esempio n. 13
0
int main(int argc, char *argv[]) {
    char *delimiter_position = NULL;
    char *command = NULL;
    int i = 0;
    if (argc < 2) {
        while(1) {
            if (getcwd(current_work_path, sizeof(current_work_path)) == NULL) {
                break;
            }
            if (getlogin_r(user, sizeof(user)) != 0) {
                break;
            }

            sprintf(PS1, "%s:%s$ ", user, current_work_path);

            if (command != NULL) {
                free(command);
                command = NULL;
            }
            
            command = readline(PS1);
            if ((command != NULL) && (*command != '\0')) {
                add_history(command);
            }
            
            delimiter_position = strtok(command, " ");
            while (delimiter_position != NULL) {
                argv[i++] = delimiter_position;
                delimiter_position = strtok(NULL, " ");
            }
            argv[i] = NULL;
            i = 0;
            
            if (strcmp(argv[0], "quit") == 0) {
                break;
            }
            
            if (strcmp(argv[0], "cd") == 0) {
                cd(argv);
                continue;
            }

            execute(argv);
        }
    } else {
        readopt(argc, argv);
    }

    
    return 0;
}
Esempio n. 14
0
void MainWindow::connect2mysql() {
    ConnectDialog cd(this);
    cd.readSettings();

    if ( cd.exec() == QDialog::Accepted ) {
       cd.writeSettings();
       try {
           md = cd.getConnection();
           QMessageBox::information(this, "Connected", "Connected to MYSQL!");
       } catch ( std::exception & e ) {
           QMessageBox::warning(this, "Failed", e.what());
       }
    }
}
void
PB_DS_CLASS_C_DEC::
copy_from_ordered_range(It first_it, It last_it, It other_first_it, 
			It other_last_it)
{
  clear();
  const size_type len = std::distance(first_it, last_it) 
    		         + std::distance(other_first_it, other_last_it);

  value_vector a_values = s_value_alloc.allocate(len);

  iterator target_it = a_values;
  It source_it = first_it;
  It source_end_it = last_it;

  cond_dtor<size_type> cd(a_values, target_it, len);
  while (source_it != source_end_it)
    {
      new (const_cast<void* >(static_cast<const void* >(target_it)))
	value_type(*source_it++);
      ++target_it;
    }

  source_it = other_first_it;
  source_end_it = other_last_it;

  while (source_it != source_end_it)
    {
      new (const_cast<void* >(static_cast<const void* >(target_it)))
	value_type(*source_it++);
      ++target_it;
    }

  reallocate_metadata((node_update* )this, len);
  cd.set_no_action();
  m_a_values = a_values;
  m_size = len;
  m_end_it = m_a_values + m_size;
  update(PB_DS_node_begin_imp(), (node_update* )this);

#ifdef _GLIBCXX_DEBUG
  const_iterator dbg_it = m_a_values;
  while (dbg_it != m_end_it)
    {
      map_debug_base::insert_new(PB_DS_V2F(*dbg_it));
      dbg_it++;
    }
  PB_DS_CLASS_C_DEC::assert_valid();
#endif 
}
Esempio n. 16
0
bool CacheManager::addEmptyEntry(const std::string& name) {
    if (entryExists(name)) {
        return false;
    }

    std::unique_ptr<CacheData> cd(new CacheData);
    cd->createEmpty(name, entry_counter_++);

    cache_map_[name] = std::move(cd);

    addDirectories(name);

    return true;
}
Esempio n. 17
0
void CacheManager::addDirectories(const std::string& path) {
    std::vector<std::string> path_list;
    path_list = TextUtil::MakePathList(path);

    if (path_list.empty()) {
        return;
    }

    for (const auto& it : path_list) {
        std::unique_ptr<CacheData> cd(new CacheData);
        cd->createDirectory(it, entry_counter_++);
        cache_map_[it] = std::move(cd);
    }
}
void collision_detection::CollisionWorldFCL::checkRobotCollisionHelper(const CollisionRequest &req, CollisionResult &res, const CollisionRobot &robot, const robot_state::RobotState &state, const AllowedCollisionMatrix *acm) const
{
  const CollisionRobotFCL &robot_fcl = dynamic_cast<const CollisionRobotFCL&>(robot);
  FCLObject fcl_obj;
  robot_fcl.constructFCLObject(state, fcl_obj);
  
  CollisionData cd(&req, &res, acm);
  cd.enableGroup(robot.getRobotModel());
  for (std::size_t i = 0 ; !cd.done_ && i < fcl_obj.collision_objects_.size() ; ++i)
    manager_->collide(fcl_obj.collision_objects_[i].get(), &cd, &collisionCallback);
  
  if (req.distance)
    res.distance = distanceRobotHelper(robot, state, acm);
}
Esempio n. 19
0
int main(int argc, char** argv)
{
    QApplication qapp(argc, argv);
    KComponentData cd("graphicsview-test");

    Calligra::Sheets::Part part;
    Calligra::Sheets::Doc doc(&part);
    part.setDocument(&doc);


    bool ok = doc.openUrl(QUrl("/home/marijn/kde/src/calligra/docs/oos_AMSAT-IARU_Link_Model.ods"));
    if (!ok) {
        qDebug() << "failed to load";
        return 0;
    }

    QFont font(KoGlobal::defaultFont());

    Calligra::Sheets::CanvasItem* canvas = new Calligra::Sheets::CanvasItem(&doc);

    QRect usedArea = canvas->activeSheet()->usedArea(true);
    QFontMetricsF fm(font, 0);
    QSizeF size(canvas->activeSheet()->columnPosition(usedArea.right()+3), canvas->activeSheet()->rowPosition(usedArea.bottom()+5));
    canvas->setDocumentSize(size);
    size = canvas->zoomHandler()->documentToView(size);
    canvas->resize(size);
    canvas->setPos(0, 0);

    Calligra::Sheets::ColumnHeaderItem* columnHeader = static_cast<Calligra::Sheets::ColumnHeaderItem*>(canvas->columnHeader());
    static_cast<QGraphicsWidget*>(columnHeader)->resize(size.width(), fm.height() + 3);
    columnHeader->setPos(0, -columnHeader->height());

    Calligra::Sheets::RowHeaderItem* rowHeader = static_cast<Calligra::Sheets::RowHeaderItem*>(canvas->rowHeader());
    static_cast<QGraphicsWidget*>(rowHeader)->resize(fm.width(QString::fromLatin1("99999")) + 3, size.height());
    rowHeader->setPos(-rowHeader->width(), 0);

    columnHeader->toolChanged("PanTool");
    rowHeader->toolChanged("PanTool");
    
    QGraphicsScene scene;
    scene.addItem(canvas);
    scene.addItem(columnHeader);
    scene.addItem(rowHeader);

    QGraphicsView view(&scene);
    view.show();

    qapp.exec();
}
Esempio n. 20
0
euint8 putty_cd(euint8* path)
{
	SDfolder original;original = currDir;/*Backup*/
	if(path[0]=='/')
	{
		//absolute address
		currDir = root;//move back to the root folder then we can begin
		strChomp(path);
	}
	else
	{
		//relative address
	}
	/*new we pass through the strings section by section attempting to move*/

	printf("-->%s\n",path);
	char* tokens[20];
   	euint8 count = string_parser2(path,tokens);
   	euint8 i=0;
   	euint8 abort=0;
   	for(i=0;i<count;i++)
   	{
	   printf("->%s\n", tokens[i]);
	   if(abort==0)
	   {
			if(cd( tokens[i])!=0)
			{
			   abort=1;
			}
			free(tokens[i]);
   	   }
   if(abort==1)
   {
	   currDir = original;
	   return -1;
   }
   else
		return 0;
}
/*Removes the first char from a string*/
void strChomp(euint8* s)
{
	euint32 i=0;
	for(i=1;i<strlen(s);i++)
	{
		s[i-1]=s[i];
	}
	s[i-1]=0;//move the null
}
Esempio n. 21
0
void QMessage::appendAttachments(const QStringList &fileNames)
{
    if (d_ptr->_message.multipartType() == QMailMessage::MultipartNone) {
        if (d_ptr->_message.hasBody()) {
            // Move the existing body to become the first part
            QMailMessageContentType ct(d_ptr->_message.contentType());
            QString bodyText(d_ptr->_message.body().data());

            QMailMessageContentDisposition cd(QMailMessageContentDisposition::Inline);
            cd.setSize(bodyText.length());

            QMailMessagePart textPart(QMailMessagePart::fromData(bodyText, cd, ct, QMailMessageBody::Base64));

            d_ptr->_message.setMultipartType(QMailMessage::MultipartMixed);
            d_ptr->_message.appendPart(textPart);
        } else {
            // Just set this message to be multipart
            d_ptr->_message.setMultipartType(QMailMessage::MultipartMixed);
        }
    }

    foreach (const QString &filename, fileNames) {
        QString mimeType(QMail::mimeTypeFromFileName(filename));
        if (!mimeType.isEmpty()) {
            QFileInfo fi(filename);

            QMailMessageContentDisposition cd(QMailMessageContentDisposition::Attachment);
            cd.setFilename(fi.fileName().toAscii());
            cd.setSize(fi.size());

            QMailMessageContentType ct(mimeType.toAscii());

            QMailMessagePart part(QMailMessagePart::fromFile(filename, cd, ct, QMailMessageBody::Base64, QMailMessageBody::RequiresEncoding));
            d_ptr->_message.appendPart(part);
        }
    }
Esempio n. 22
0
double collision_detection::CollisionRobotFCL::distanceSelfHelper(const planning_models::KinematicState &state,
        const AllowedCollisionMatrix *acm) const
{
    FCLManager manager;
    allocSelfCollisionBroadPhase(state, manager);

    CollisionRequest req;
    CollisionResult res;
    CollisionData cd(&req, &res, acm);
    cd.enableGroup(getKinematicModel());

    manager.manager_->distance(&cd, &distanceCallback);

    return res.distance;
}
Esempio n. 23
0
int check_built_in(char **command, int num_args, char **path_list, int *path_num) {
	
	if(cd(command, num_args) == 0) {
		return 0;
	}
	else if(pwd(command) == 0) {
		return 0;
	}
	else if(path(command, num_args, path_list, path_num) == 0) {
		return 0;
	}
	else {
		return 1;
	}
}
Esempio n. 24
0
HRESULT VFSExplorer::cdUp(ComPtr<IProgress> &aProgress)
{
    Utf8Str strUpPath;
    {
        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
        /* Remove lowest dir entry in a platform neutral way. */
        char *pszNewPath = RTStrDup(m->strPath.c_str());
        RTPathStripTrailingSlash(pszNewPath);
        RTPathStripFilename(pszNewPath);
        strUpPath = pszNewPath;
        RTStrFree(pszNewPath);
    }

    return cd(strUpPath, aProgress);
}
Esempio n. 25
0
//
//InspectCreatureDefMessage
//
int InspectCreatureDefMessage::handleMessage(SimulatorThread *sim, CharacterServerData *pld,
		SimulatorQuery *query, CreatureInstance *creatureInstance) {

	int CDefID = GetInteger(&sim->readPtr[sim->ReadPos], sim->ReadPos);

	g_CharacterManager.GetThread("SimulatorThread::handle_inspectCreatureDef");
	CharacterData *charData = g_CharacterManager.GetPointerByID(CDefID);
	g_CharacterManager.ReleaseThread();
	if (charData != NULL) {
		/* Is a player, is it for a player in the current active instance? If so, we need
		 * appearance modifiers so use the creature instance's calculated appearance.
		 *
		 * TODO Em - I don't really like this. It makes me wonder if modifiers should
		 * be on the creature def.
		 */
		CreatureInstance* cInst =
				creatureInstance == NULL || creatureInstance->actInst == NULL ?
						NULL :
						creatureInstance->actInst->GetPlayerByCDefID(
								charData->cdef.CreatureDefID);
		if (cInst != NULL) {
			CreatureDefinition cd(charData->cdef);
			cd.css.SetAppearance(cInst->PeekAppearance().c_str());
			cd.css.SetEqAppearance(cInst->PeekAppearanceEq().c_str());
			return PrepExt_CreatureDef(sim->SendBuf, &cd);

//			std::string currentAppearance = charData->cdef.css.appearance;
//			std::string currentEqAppearance = charData->cdef.css.eq_appearance;
//			charData->cdef.css.SetAppearance(cInst->PeekAppearance().c_str());
//			charData->cdef.css.SetEqAppearance(cInst->PeekAppearanceEq().c_str());
//
//			AttemptSend(SendBuf, PrepExt_CreatureDef(SendBuf, &charData->cdef));
//
//			charData->cdef.css.SetAppearance(currentAppearance.c_str());
//			charData->cdef.css.SetEqAppearance(currentEqAppearance.c_str());
		} else
			return PrepExt_CreatureDef(sim->SendBuf, &charData->cdef);
	} else {
		CreatureDefinition *target = CreatureDef.GetPointerByCDef(CDefID);
		if (target != NULL)
			return PrepExt_CreatureDef(sim->SendBuf, target);
		else
			g_Logs.simulator->warn(
					"[%d] inspectCreatureDef: could not find ID [%d]",
					sim->InternalID, CDefID);
	}
	return 0;
}
Esempio n. 26
0
void CommitDetailsTest::test_clear()
{
  CommitDetails cd(nullptr, "//Root/Path/To/Node");

  QVERIFY( !cd.hasOptions() );

  QCOMPARE( cd.nodePath(), QString("//Root/Path/To/Node") );
  cd.setOption("Option1", "OldVal", "NewVal");

  QVERIFY( cd.hasOptions() );

  cd.clear();

  QVERIFY( !cd.hasOptions() );
  QVERIFY( cd.nodePath().isEmpty() );
}
Esempio n. 27
0
	QDir CreateIfNotExists (QString path)
	{
		auto home = QDir::home ();
		path.prepend (".leechcraft/");

		if (!home.exists (path) &&
				!home.mkpath (path))
			throw std::runtime_error (qPrintable (QObject::tr ("Could not create %1")
						.arg (QDir::toNativeSeparators (home.filePath (path)))));

		if (home.cd (path))
			return home;
		else
			throw std::runtime_error (qPrintable (QObject::tr ("Could not cd into %1")
						.arg (QDir::toNativeSeparators (home.filePath (path)))));
	}
Esempio n. 28
0
  void playWithHomeTheaterFacade() {
    // Create all the parts of the home theatre system
    // Not encapsulated or owned by the facade.
    Amplifier amp("Top-O-Line Amplifier");
    CdPlayer cd("Top-O-Line CD Player", &amp);
    DvdPlayer dvd("Top-O-Line DVD Player", &amp);
    Screen screen("My Theater Screen");
    PopcornPopper popper("My Popcorn Popper");
    Tuner tuner("Top-O-Line AM/FM Tuner", &amp);
    TheaterLights lights("Theater Ceiling Lights");
    Projector projector("Top-O-Line Projector");

    HomeTheaterFacade theater(&amp, &tuner, &dvd, &cd, &projector, &lights, &screen, &popper);
    theater.watchMovie("Raiders of the Lost Ark");
    theater.endMovie();
  }
Esempio n. 29
0
File: rsa.c Progetto: sh1457/labs
/***************************************************************************
*Function : ce
*RETURNS :	None
***************************************************************************/
void ce() {
  int k=0;
  for(i=2; i<t; i++) {
    if(t%i == 0)
      continue;
    flag = prime(i);
    if(flag==1 && i!=p && i!=q) {
      e[k] = i;
      flag = cd(e[k]);
      if(flag > 0)
        d[k++] = flag;
      if(k == 99)
        break;
    }
  }
}
int seg_intersection(const point &a, const point &b, const point &c,
                     const point &d, point *p = NULL, point *q = NULL) {
  static const bool TOUCH_IS_INTERSECT = true;
  point ab(b.x - a.x, b.y - a.y);
  point ac(c.x - a.x, c.y - a.y);
  point cd(d.x - c.x, d.y - c.y);
  double c1 = cross(ab, cd), c2 = cross(ac, ab);
  if (EQ(c1, 0) && EQ(c2, 0)) {  // Collinear.
    double t0 = dot(ac, ab) / sqnorm(ab);
    double t1 = t0 + dot(cd, ab) / sqnorm(ab);
    double mint = std::min(t0, t1), maxt = std::max(t0, t1);
    bool overlap = TOUCH_IS_INTERSECT ? (LE(mint, 1) && LE(0, maxt))
                                      : (LT(mint, 1) && LT(0, maxt));
    if (overlap) {
      point res1 = std::max(std::min(a, b), std::min(c, d));
      point res2 = std::min(std::max(a, b), std::max(c, d));
      if (res1 == res2) {
        if (p != NULL) {
          *p = res1;
        }
        return 0;  // Collinear and meeting at an endpoint.
      }
      if (p != NULL && q != NULL) {
        *p = res1;
        *q = res2;
      }
      return 1;  // Collinear and overlapping.
    } else {
      return -1;  // Collinear and disjoint.
    }
  }
  if (EQ(c1, 0)) {
    return -1;  // Parallel and disjoint.
  }
  double t = cross(ac, cd)/c1, u = c2/c1;
  bool t_between_01 = TOUCH_IS_INTERSECT ? (LE(0, t) && LE(t, 1))
                                         : (LT(0, t) && LT(t, 1));
  bool u_between_01 = TOUCH_IS_INTERSECT ? (LE(0, u) && LE(u, 1))
                                         : (LT(0, u) && LT(u, 1));
  if (t_between_01 && u_between_01) {
    if (p != NULL) {
      *p = point(a.x + t*ab.x, a.y + t*ab.y);
    }
    return 0;  // Non-parallel with one intersection.
  }
  return -1;  // Non-parallel with no intersections.
}