public RloMethodConverter(TagRepository tagRepo, RloInstantiationParameters instParams, TypeSpecTag returnType, HighLocal instanceLocal, HighLocal[] args, HighLocal[] locals)
{
m_tagRepo = tagRepo;
m_instParams = instParams;
m_returnType = InstantiateType(returnType);
List<HighLocal> mergedLocals = new List<HighLocal>();
if (instanceLocal != null)
mergedLocals.Add(instanceLocal);
mergedLocals.AddRange(args);
mergedLocals.AddRange(locals);
foreach (HighLocal local in mergedLocals)
{
HighLocal newLocal = new HighLocal(this.InstantiateType(local.Type), local.TypeOfType);
m_translatedLocals.Add(local, newLocal);
}
if (instanceLocal != null)
m_instanceLocal = m_translatedLocals[instanceLocal];
List<HighLocal> newArgs = new List<HighLocal>();
foreach (HighLocal arg in args)
newArgs.Add(m_translatedLocals[arg]);
List<HighLocal> newLocals = new List<HighLocal>();
foreach (HighLocal local in locals)
newLocals.Add(m_translatedLocals[local]);
m_args = newArgs.ToArray();
m_locals = newLocals.ToArray();
}
public static HighRegion Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
uint numCfgNodes = reader.ReadUInt32();
if (numCfgNodes == 0)
throw new Exception("Region has no CFG nodes");
HighCfgNodeHandle[] cfgNodes = new HighCfgNodeHandle[numCfgNodes];
for (uint i = 0; i < numCfgNodes; i++)
cfgNodes[i] = new HighCfgNodeHandle();
for (uint i = 0; i < numCfgNodes; i++)
cfgNodes[i].Value = HighCfgNode.Read(rpa, catalog, methodBody, cfgNodes, baseLocation, haveDebugInfo, reader);
RegionPhiResolver phiResolver = new RegionPhiResolver(cfgNodes);
for (uint i = 0; i < numCfgNodes; i++)
{
foreach (HighPhi phi in cfgNodes[i].Value.Phis)
phi.Resolve(phiResolver);
}
HighCfgNodeHandle entryNode = cfgNodes[0];
if (entryNode.Value.Phis.Length != 0)
throw new RpaLoadException("Region entry node has phis");
return new HighRegion(entryNode);
}
public static HighEscapePathTerminator Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, HighCfgNodeHandle[] cfgNodes, BinaryReader reader)
{
uint escapePath = reader.ReadUInt32();
HighCfgNodeHandle cfgNode = cfgNodes[reader.ReadUInt32()];
return new HighEscapePathTerminator(escapePath, cfgNode);
}
public static HighProtectedRegion Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
HighProtectedRegion region;
RegionTypeEnum regionType = (RegionTypeEnum)reader.ReadByte();
HighRegion tryRegion = HighRegion.Read(rpa, catalog, methodBody, baseLocation, haveDebugInfo, reader);
switch (regionType)
{
case RegionTypeEnum.TryCatch:
region = new HighTryCatchRegion(tryRegion);
break;
case RegionTypeEnum.TryFault:
region = new HighTryFaultRegion(tryRegion);
break;
case RegionTypeEnum.TryFinally:
region = new HighTryFinallyRegion(tryRegion);
break;
default:
throw new Exception("Invalid protected region type");
}
region.ReadHandlers(rpa, catalog, methodBody, baseLocation, haveDebugInfo, reader);
return region;
}
public UnitOfWork()
{
articleRepository = new ArticleRepository(db);
reviewRepository = new ReviewRepository(db);
questionRepository = new QuestionRepository(db);
userRepository = new UserRepository(db);
tagRepository = new TagRepository(db);
}
public ImageController(ImageRepository imageRepository, TagRepository tagRepository, AlbumsRepository albumsRepository, AlbumsImagesRepository albumsImagesRepository, IFileManager fileManager)
{
this.imageRepository = imageRepository;
this.tagRepository = tagRepository;
this.albumsRepository = albumsRepository;
this.albumsImagesRepository = albumsImagesRepository;
this.fileManager = fileManager;
}
public void Setup()
{
TagRepository tagRepository = new TagRepository();
tagRepository.FilePath = "data/initial_tags.json";
tagRepository.InitializeFromFile();
ILocationProvider locationProvider = new MockLocationProvider();
_parser = new RegexMessageParser(tagRepository, locationProvider);
}
public MainWindowViewModel()
{
Content = new HomeMenuViewModel();
CategoryRepository.Initialize();
TagRepository.Initialize();
DirectoryRepository.Initialize();
FileSystemConnector.EnsureCreated();
}
public Post Save(TestContext context)
{
var tags = new TagRepository(context);
Post.Tags = Post.Tags.Select(x => tags.Get(x.Name) ?? tags.Save(new Tag(x.Name))).ToList();
new PostRepository(context).Save(Post);
tags.Commit();
return Post;
}
private async Task <List <TagDto> > GetTagsOfPostAsync(Guid id)
{
var tagIds = (await PostRepository.GetAsync(id)).Tags;
var tags = await TagRepository.GetListAsync(tagIds.Select(t => t.TagId));
return(ObjectMapper.Map <List <Tag>, List <TagDto> >(tags));
}
public BlogDetailManager(IUserInterfaceManager parentUI, string connectionString, int authorId)
{
_parentUI = parentUI;
_blogRepository = new BlogRepository(connectionString);
_postRepository = new PostRepository(connectionString);
_tagRepository = new TagRepository(connectionString);
_blogId = authorId;
}
public NoteManagementManager(IUserInterfaceManager parentUI, string connectionString)
{
_parentUI = parentUI;
_authorRepository = new AuthorRepository(connectionString);
_postRepository = new PostRepository(connectionString);
_noteRepository = new NoteRepository(connectionString);
_tagRepository = new TagRepository(connectionString);
}
public HomeController()
{
authContext = new ApplicationDbContext();
manualRepository = new ManualRepository(new ApplicationDbContext());
categoryRepository = new CategoryRepository(new ApplicationDbContext());
tagRepository = new TagRepository(new ApplicationDbContext());
ratingRepository = new RatingRepository(new ApplicationDbContext());
}
public void CanFailWithNullDescriptionAndNullTagType()
{
TagRepository repo = new TagRepository();
Assert.Throws(typeof(SQLiteException), () =>
repo.Add(new Tag())
);
}
public override TypeSpecTag Instantiate(TagRepository repo, TypeSpecTag[] typeParams, TypeSpecTag[] methodParams)
{
if (m_genericParamType.Value == TypeSpecGenericParamTypeTag.Values.Var)
return typeParams[m_index];
else if (m_genericParamType.Value == TypeSpecGenericParamTypeTag.Values.MVar)
return methodParams[m_index];
throw new Exception();
}
public EditTagModel(UserManager <Employee> userManager,
RoleManager <EmployeeRole> roleManager,
TagRepository tags)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.tags = tags;
}
public ProjectDetailViewModel(Project project)
{
Project = project;
DisplayName = project.ProjectName;
Reviews = new ReviewRepository(reviewData).Reviews;
Tags = new TagRepository(tagData).Tags;
Inspections = new InspectionRepository(inspectionData).Inspections;
}
public AddTagModel(UserManager <Employee> userManager,
RoleManager <EmployeeRole> roleManager,
TagRepository companies)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.companies = companies;
}
public EntityRepositoryTest()
{
this.liteDb = new LiteRepository(new MemoryStream());
this.entityRepository = new EntityRepository(this.liteDb);
this.tagRepository = new TagRepository(this.liteDb);
this.categoryRepository = new CategoryRepository(this.liteDb);
this.entities = this.liteDb.Database.GetCollection("entities");
}
private SVP.CIL.Domain.Tag TagRead(AppDbContext dbc, SVP.CIL.Domain.Tag target)
{
var repo = new TagRepository(dbc);
var tag = repo.Load(target.Id);
var domainTag = Mapper.Map <SVP.CIL.Domain.Tag>(tag);
return(domainTag);
}
private MediaRepository CreateMediaRepository(IScopeUnitOfWork unitOfWork, out IMediaTypeRepository mediaTypeRepository)
{
mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var tagRepository = new TagRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax);
var repository = new MediaRepository(unitOfWork, CacheHelper, Mock.Of <ILogger>(), SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of <IContentSection>());
return(repository);
}
public PostDetailManager(IUserInterfaceManager parentUI, string connectionString, int postId)
{
_parentUI = parentUI;
_authorRepository = new AuthorRepository(connectionString);
_postRepository = new PostRepository(connectionString);
_tagRepository = new TagRepository(connectionString);
_postId = postId;
}
public FanficBuilderController(ApplicationContext context)
{
FanficRepository = new FanficRepository(context);
TopicRepository = new TopicRepository(context);
FanficTagRepository = new FanficTagRepository(context);
TagRepository = new TagRepository(context);
ApplicationUserRepository = new ApplicationUserRepository(context);
}
public override void ReadHeader(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, HighCfgNodeHandle[] cfgNodes, List<HighSsaRegister> ssaRegisters, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
m_arithOp = (NumberUnaryArithOp)reader.ReadByte();
if (m_arithOp < 0 || m_arithOp >= NumberUnaryArithOp.NumHighUnaryArithOpTypes)
throw new Exception("Invalid unary arithmetic op");
m_arithType = (NumberArithType)reader.ReadByte();
if (m_arithType < 0 || m_arithType >= NumberArithType.NumHighArithTypes)
throw new Exception("Invalid arith type");
}
public async Task Create_ValidParameters_AddsTagNameParameter()
{
const string expected = "tagName";
var sut = new TagRepository(_requestFactory);
await sut.Create(0, expected, "refName");
_request.Received().AddParameter("tag_name", expected);
}
public async Task Create_ReleaseDescriptionIsSet_AddsReleaseDescriptionParameter()
{
const string expected = "releaseDescription";
var sut = new TagRepository(_requestFactory);
await sut.Create(0, "tagName", "refName", releaseDescription : expected);
_request.Received().AddParameterIfNotNull("release_description", expected);
}
public async Task Create_ValidParameters_AddsProjectIdUrlSegment()
{
const uint expected = 0;
var sut = new TagRepository(_requestFactory);
await sut.Create(expected, "tagName", "refName");
_request.Received().AddUrlSegment("projectId", expected);
}
public async Task UpdateRelease_ValidParameters_AddsTagNameUrlSegment()
{
const string expected = "tagName";
var sut = new TagRepository(_requestFactory);
await sut.UpdateRelease(0, expected, "description");
_request.Received().AddUrlSegment("tagName", expected);
}
public TagsController(ILogger <TagsController> logger,
IOptions <AppSettings> settings,
IConfiguration configuration,
IHttpContextAccessor accessor)
: base(logger, settings, configuration)
{
_accessor = accessor;
TagRepository = new TagRepository();
}
public TagTest()
{
var context = new ApplicationContext(dbContextOptions);
DummyDataDBInitializer db = new DummyDataDBInitializer();
db.Seed(context);
repository = new TagRepository(context);
}
public PostController(Account _account, PostRepository _post_repo, TagRepository _tag_repo, PostTagRepository _post_tag_repo, CategoryPostRepository _category_post_repository, CategoryRepository _category_repository)
{
this._account = _account;
this._post_repo = _post_repo;
this._tag_repo = _tag_repo;
this._post_tag_repo = _post_tag_repo;
this._category_repository = _category_repository;
this._category_post_repository = _category_post_repository;
}
public ActionResult Remove(long tag_id, string field_name)
{
using (TagRepository tag_repository = new TagRepository())
{
tag_repository.Remove(tag_id);
}
return(RedirectToAction("Index", new { field_name = field_name }));
}
public HighMethod(HighMethod baseMethod, TagRepository repo, TypeSpecTag[] argTypes)
{
m_static = baseMethod.m_static;
m_methodSignature = baseMethod.m_methodSignature.Instantiate(repo, argTypes);
m_methodBody = baseMethod.m_methodBody;
m_methodDeclTag = baseMethod.m_methodDeclTag;
m_isInternal = baseMethod.m_isInternal;
}
/// <inheritdoc />
public async Task <IReadOnlyCollection <TagSummary> > GetSummariesAsync(TagSearchCriteria criteria)
{
if (criteria is null)
{
throw new ArgumentNullException(nameof(criteria));
}
return(await TagRepository.SearchSummariesAsync(criteria));
}
public UnitOfWork(ShareMeContext context)
{
this.context = context;
UserRepository = new UserRepository(context);
TagRepository = new TagRepository(context);
PostRepository = new PostRepository(context);
CommentRepository = new CommentRepository(context);
CategoryRepository = new CategoryRepository(context);
}
public JsonResult AddTag([FromBody] TagModel model)
{
if (model.Url == null || model.Title == null)
{
return(new JsonResult(false));
}
TagRepository.CreateTag(model.Url, "", model.TagType, model.Title);
return(new JsonResult(true));
}
private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
{
memberTypeRepository = new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
memberGroupRepository = new MemberGroupRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, CacheHelper.CreateDisabledCacheHelper());
var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of <IContentSection>());
return(repository);
}
public HomeController(UserManager <ApplicationUser> userManager, ArticleRepository articleRepository, TagRepository tagRepository,
MarkRepository markRepository, SearchService searchService)
{
_userManager = userManager;
_articleRepository = articleRepository;
_tagRepository = tagRepository;
_markRepository = markRepository;
_searchService = searchService;
}
public UnitOfWork(SecurityDbContext context)
{
_context = context;
UserRepository = new UserRepository(_context);
UserGroupRepository = new UserGroupRepository(_context);
CatalogRepository = new CatalogRepository(_context);
ResourceRepository = new ResourceRepository(_context);
TagRepository = new TagRepository(_context);
}
public async Task UpdateRelease_ValidParameters_AddsProjectIdUrlSegment()
{
const uint expected = 0;
var sut = new TagRepository(_requestFactory);
await sut.UpdateRelease(expected, "tagName", "description");
_request.Received().AddUrlSegment("projectId", expected);
}
public static HighPhi Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, HighCfgNodeHandle[] cfgNodes, uint[] predecessors, BinaryReader reader)
{
HighSsaRegister dest = HighSsaRegister.ReadDestinationDef(rpa, catalog, reader);
if (dest == null)
throw new Rpa.RpaLoadException("Phi has no destination");
HighUnresolvedPhiCollection unresolvedCollection = HighUnresolvedPhiCollection.Read(rpa, catalog, cfgNodes, predecessors, reader);
return new HighPhi(dest, unresolvedCollection);
}
public Database()
{
// get config and context from request
this.SqlConfig = HttpContext.Current.Items["config"] as SqlConfig;
this.SqlContext = HttpContext.Current.Items["context"] as SqlContext;
BookEntity = new BookRepository(this.SqlConfig, this.SqlContext);
CategoryEntity = new CategoryRepository(this.SqlConfig, this.SqlContext);
TagEntity = new TagRepository(this.SqlConfig, this.SqlContext);
Tag2BookEntity = new Tag2BookRepository(this.SqlConfig, this.SqlContext);
}
protected override void ReadHandlers(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
uint numCatchHandlers = reader.ReadUInt32();
m_catchHandlers = new HighCatchHandler[numCatchHandlers];
for (uint i = 0; i < numCatchHandlers; i++)
{
HighCatchHandler hdl = new HighCatchHandler();
hdl.Read(rpa, catalog, methodBody, baseLocation, haveDebugInfo, reader);
m_catchHandlers[i] = hdl;
}
}
public void CreateNewTagSuccessfulTest()
{
using (UnitOfWork uow = new UnitOfWork())
{
TagRepository tr = new TagRepository(uow.Current);
Tag c = new Tag("sql server");
tr.Save(c);
uow.Commit();
}
}
public void GetAllNamesReturnsCorrectNames()
{
// Arrange
ITagRepository repo = new TagRepository( Session );
// Act
string[] one = repo.GetAllNames( TestProject ).ToArray();
string[] two = repo.GetAllNames( TestProject2 ).ToArray();
// Assert
CollectionAssert.AreEquivalent( TestData.Where( t => t.Project.Id == TestProject.Id ).Select( t => t.Name ).ToArray(), one );
CollectionAssert.AreEquivalent( TestData.Where( t => t.Project.Id == TestProject2.Id ).Select( t => t.Name ).ToArray(), two );
}
public void SerializeDemoMessagesToFile()
{
ILocationProvider locationProvider = new MockLocationProvider();
IMessageParser realMessageParser = new RegexMessageParser(_singletonTagProvider, locationProvider);
MessageRepository tempMessageRepository = new MessageRepository();
TagRepository tempTagRepository = new TagRepository();
IncomingMessageProcessor incomingMessageProcessor = new IncomingMessageProcessor(tempMessageRepository, tempTagRepository, realMessageParser);
IRawMessageProvider rawMessageProvider = new DemoMessageProvider(incomingMessageProcessor);
rawMessageProvider.Update();
tempMessageRepository.FilePath = "../../data/demo_offers.json";
tempMessageRepository.SerializeToFile();
}
public static HighUnresolvedPhiCollection Read(TagRepository rpa, CatalogReader catalog, HighCfgNodeHandle[] cfgNodes, uint[] predecessors, BinaryReader reader)
{
int numLinks = predecessors.Length;
List<UnresolvedLink> links = new List<UnresolvedLink>();
foreach (uint pred in predecessors)
{
UnresolvedLink link = UnresolvedLink.Read(rpa, catalog, pred, reader);
links.Add(link);
}
return new HighUnresolvedPhiCollection(links.ToArray());
}
public static void Initialize()
{
UserRepository = new UserRepository();
PostRepository = new PostRepository();
HeaderImageRepository = new HeaderImageRepository();
MessageRepository = new MessageRepository();
CommentRepository = new CommentRepository();
PostVotingRepository = new PostVotingRepository();
CommentVotingRepository = new CommentVotingRepository();
MessageSettingsRepository = new MessageSettingsRepository();
TagRepository = new TagRepository();
TagPostRepository = new TagPostRepository();
}
public void TestInitialize()
{
var context = ContextFactory.GetContext();
webLogRepository = new GenericRepository<WebLog>(context);
userRepository = new GenericRepository<User>(context);
tagRepository = new TagRepository(context);
// zero o banco antes de executar cada teste
//tagRepository.Select().ToList().ForEach(t => tagRepository.Delete(t));
//userRepository.Select().ToList().ForEach(u => userRepository.Delete(u));
//webLogRepository.Select().ToList().ForEach(w => webLogRepository.Delete(w));
//context.SaveChanges();
}
public TestSerialization()
{
_singletonTagProvider = new TagRepository();
_singletonTagProvider.FilePath = "data/initial_tags.json";
_singletonTagProvider.InitializeFromFile();
ILocationProvider locationProvider = new MockLocationProvider();
IMessageParser realMessageParser = new RegexMessageParser(_singletonTagProvider, locationProvider);
_messageRepository = new MessageRepository();
_tagRepository = new TagRepository();
IncomingMessageProcessor incomingMessageProcessor = new IncomingMessageProcessor(_messageRepository, _tagRepository, realMessageParser);
IRawMessageProvider rawMessageProvider = new MockRawMessageProvider(incomingMessageProcessor);
rawMessageProvider.Update();
}
public TestMessageExecutor()
{
MockMessageParser mockParser = new MockMessageParser();
ignoredUsers = new IgnoredUserRepository();
//var ignoredUser = MockData.Users[0];
//signoredUsers.Save(ignoredUser);
MessageRepository messageRepository = new MessageRepository(ignoredUsers);
TagRepository tagRepository = new TagRepository();
IncomingMessageProcessor incomingMessageProcessor = new IncomingMessageProcessor(messageRepository,tagRepository, mockParser);
//_target = new TagDexQueryExecutor();
MockRawMessageProvider mockProvider = new MockRawMessageProvider(incomingMessageProcessor);
_target = messageRepository;
mockProvider.Update();
}
public static HighEHCluster Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, HighCfgNodeHandle[] cfgNodes, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
uint numTerminators = reader.ReadUInt32();
HighEscapePathTerminator[] escapePathTerminators = new HighEscapePathTerminator[numTerminators];
for (uint i = 0; i < numTerminators; i++)
{
HighEscapePathTerminator terminator = HighEscapePathTerminator.Read(rpa, catalog, methodBody, cfgNodes, reader);
escapePathTerminators[i] = terminator;
}
HighProtectedRegion protRegion = HighProtectedRegion.Read(rpa, catalog, methodBody, baseLocation, haveDebugInfo, reader);
return new HighEHCluster(protRegion, escapePathTerminators);
}
public void InitializeTwitterProvider()
{
//for this test create real objects all the way down the line - so...more of an integration test really
// (which is why this is disabled)
TagRepository singletonTagProvider = new TagRepository();
singletonTagProvider.FilePath = "data/initial_tags.json";
singletonTagProvider.InitializeFromFile();
ILocationProvider locationProvider = new MockLocationProvider();
RegexMessageParser realMessageParser = new RegexMessageParser(singletonTagProvider, locationProvider);
_messageRepository = new MessageRepository();
_tagRepository = new TagRepository();
IncomingMessageProcessor target = new IncomingMessageProcessor(_messageRepository, _tagRepository, realMessageParser);
TwitterRawMessageProvider twitterProvider = new TwitterRawMessageProvider((IRawMessageReceiver)target, new MockWebRequestFactory());
twitterProvider.Update();
}
public PageServices(PXHotelEntities entities)
{
_localizedResourceServices = HostContainer.GetInstance<ILocalizedResourceServices>();
_pageTemplateServices = HostContainer.GetInstance<IPageTemplateServices>();
_curlyBracketServices = HostContainer.GetInstance<ICurlyBracketServices>();
_clientMenuServices = HostContainer.GetInstance<IClientMenuServices>();
_pageLogServices = HostContainer.GetInstance<IPageLogServices>();
_settingServices = HostContainer.GetInstance<ISettingServices>();
_templateServices = HostContainer.GetInstance<ITemplateServices>();
_userServices = HostContainer.GetInstance<IUserServices>();
_pageRepository = new PageRepository(entities);
_clientMenuRepository = new ClientMenuRepository(entities);
_pageLogRepository = new PageLogRepository(entities);
_pageTagRepository = new PageTagRepository(entities);
_tagRepository = new TagRepository(entities);
}
public static HighCfgNode Read(TagRepository rpa, CatalogReader catalog, HighMethodBodyParseContext methodBody, HighCfgNodeHandle[] cfgNodes, CodeLocationTag baseLocation, bool haveDebugInfo, BinaryReader reader)
{
uint numPredecessors = reader.ReadUInt32();
uint numPhis = reader.ReadUInt32();
uint numInstructions = reader.ReadUInt32();
uint numConstants = reader.ReadUInt32();
List<HighPhi> phis = new List<HighPhi>();
List<HighInstruction> instructions = new List<HighInstruction>();
List<HighSsaRegister> ssaRegisters = new List<HighSsaRegister>();
List<uint> predecessors = new List<uint>();
List<HighCfgNodeHandle> realPreds = new List<HighCfgNodeHandle>();
// WARNING: SSA indexes from phis and constants must match CollectRegsFromNode
for (uint i = 0; i < numPredecessors; i++)
{
uint predIndex = reader.ReadUInt32();
predecessors.Add(predIndex);
realPreds.Add(cfgNodes[predIndex]);
}
uint[] predecessorsArray = predecessors.ToArray();
for (uint i = 0; i < numPhis; i++)
{
HighPhi phi = HighPhi.Read(rpa, catalog, methodBody, cfgNodes, predecessorsArray, reader);
phis.Add(phi);
ssaRegisters.Add(phi.Dest);
}
for (uint i = 0; i < numConstants; i++)
{
HighSsaRegister constant = HighSsaRegister.ReadConstant(rpa, catalog, reader);
ssaRegisters.Add(constant);
}
if (numInstructions == 0)
throw new RpaLoadException("Empty CFG node");
for (uint i = 0; i < numInstructions; i++)
{
HighInstruction instr = HighInstruction.Read(rpa, catalog, methodBody, cfgNodes, ssaRegisters, baseLocation, haveDebugInfo, reader);
instructions.Add(instr);
}
return new HighCfgNode(realPreds.ToArray(), phis.ToArray(), instructions.ToArray());
}
public void ShouldIgnoreDecrementPictureCountOnNewTag()
{
var tagName = "newtag";
Tag newTag = null;
var mockStorage = new Mock<IStorageContext>();
mockStorage.Setup(s => s.AddOrUpdateEntity<Tag>(It.IsAny<Tag>(), StorageAccountConfiguration.TagsTable)).Callback<Tag, string>((t, n) =>
{
newTag = t;
});
var repository = new TagRepository(mockStorage.Object);
repository.DecrementPictureCount(tagName);
Assert.IsNull(newTag);
mockStorage.Verify(s => s.AddOrUpdateEntity(It.IsAny<Tag>(), StorageAccountConfiguration.TagsTable), Times.Never());
}
// Export exists in CppBuilder.ExportClassDefinitions
public static HighMethod Read(TagRepository rpa, CatalogReader catalog, BinaryReader reader, TypeNameTag declaringClass)
{
bool isStatic = reader.ReadBoolean();
MethodSignatureTag methodSignature = catalog.GetMethodSignature(reader.ReadUInt32());
string name = catalog.GetString(reader.ReadUInt32());
MethodDeclTag methodDeclTag = new MethodDeclTag(name, methodSignature, declaringClass);
methodDeclTag = rpa.InternMethodDeclTag(methodDeclTag);
bool isInternal = reader.ReadBoolean();
HighMethodBody methodBody;
if (isInternal)
methodBody = null;
else
methodBody = HighMethodBody.Read(rpa, catalog, methodDeclTag, reader);
return new HighMethod(isStatic, methodSignature, methodBody, methodDeclTag, isInternal);
}
public static HighMethodBody Read(TagRepository rpa, CatalogReader catalog, MethodDeclTag methodDecl, BinaryReader reader)
{
bool haveInstanceLocal = reader.ReadBoolean();
uint numArgs = reader.ReadUInt32();
uint numLocals = reader.ReadUInt32();
bool haveDebugInfo = reader.ReadBoolean();
HighLocal instanceLocal;
if (haveInstanceLocal)
{
instanceLocal = new HighLocal();
instanceLocal.Read(rpa, catalog, reader);
}
else
instanceLocal = null;
HighLocal[] args = new HighLocal[numArgs];
HighLocal[] locals = new HighLocal[numLocals];
for (uint i = 0; i < numArgs; i++)
{
HighLocal arg = new HighLocal();
arg.Read(rpa, catalog, reader);
args[i] = arg;
}
for (uint i = 0; i < numLocals; i++)
{
HighLocal local = new HighLocal();
local.Read(rpa, catalog, reader);
locals[i] = local;
}
HighMethodBodyParseContext parseContext = new HighMethodBodyParseContext(instanceLocal, args, locals);
CodeLocationTag baseLocation = new CodeLocationTag(methodDecl, 0);
HighRegion region = HighRegion.Read(rpa, catalog, parseContext, baseLocation, haveDebugInfo, reader);
return new HighMethodBody(region, instanceLocal, args, locals, haveDebugInfo);
}
public CatalogReader(TagRepository rpa, BinaryReader reader)
{
uint numStrings = reader.ReadUInt32();
m_strings = new string[numStrings];
for (uint i = 0; i < numStrings; i++)
m_strings[i] = reader.ReadString();
uint numTypeNames = reader.ReadUInt32();
m_typeNames = new List<TypeNameTag>();
for (uint i = 0; i < numTypeNames; i++)
m_typeNames.Add(rpa.InternTypeName(TypeNameTag.Read(this, reader)));
uint numTypeSpecs = reader.ReadUInt32();
m_typeSpecs = new List<TypeSpecTag>();
for (uint i = 0; i < numTypeSpecs; i++)
m_typeSpecs.Add(rpa.InternTypeSpec(TypeSpecTag.ReadVariant(this, reader)));
uint numMethodSignatures = reader.ReadUInt32();
m_methodSignatures = new MethodSignatureTag[numMethodSignatures];
for (uint i = 0; i < numMethodSignatures; i++)
m_methodSignatures[i] = rpa.InternMethodSignature(MethodSignatureTag.Read(this, reader));
uint numVtableSlotTags = reader.ReadUInt32();
m_methodDeclTags = new MethodDeclTag[numVtableSlotTags];
for (uint i = 0; i < numVtableSlotTags; i++)
m_methodDeclTags[i] = rpa.InternMethodDeclTag(MethodDeclTag.Read(this, reader));
uint numMethodSpecs = reader.ReadUInt32();
m_methodSpecs = new MethodSpecTag[numMethodSpecs];
for (uint i = 0; i < numMethodSpecs; i++)
m_methodSpecs[i] = rpa.InternMethodSpec(MethodSpecTag.Read(this, reader));
m_assemblyName = GetString(reader.ReadUInt32());
if (!rpa.RegisterAssembly(m_assemblyName))
throw new Exception("Assembly registered multiple times");
}
public TagListViewModel( IProjectListViewModel projectList )
{
TagRepo = new TagRepository( Session );
ProjectList = projectList;
ProjectList.CurrentProjectChanged += ProjectList_CurrentProjectChanged;
var tags = Enumerable.Empty<TagViewModel>();
if( ProjectList.CurrentProject != null )
{
tags = ProjectList.CurrentProject.Model.Tags.Select( t => new TagViewModel( t ) );
}
Tags = new ObservableCollection<TagViewModel>( tags );
AvailableColors = new List<Color>( GetAllColors().OrderBy( CalculateHue ) );
TagNames = new List<string>();
Validate( nameof( NewTagName ) ).Check( () => !string.IsNullOrWhiteSpace( NewTagName ) ).Message( Strings.TagMustHaveName );
Validate( nameof( NewTagName ) ).Check( () => !TagNames.Contains( NewTagName ) ).Message( Strings.ThisNameIsAlreadyUsed );
Reset();
}
